from wx import ImageFromStream, BitmapFromImage, EmptyIcon
import cStringIO, zlib


catalog = {}
index = []

class ImageClass: pass

def get12Data():
    return zlib.decompress(
'x\xda\xeb\x0c\xf0s\xe7\xe5\x92\xe2b``\xe0\xf5\xf4p\t\x02\xd2\xee@\x9c\xc0\
\xc1\x04$\x0fT\xff8\x06\xa4\x98\x8b\x9d<C888n?\xf4\x7f\xc0\xc0\xc0\xc4\xed\
\xe9\xe2\x18R1\xe7\xed\xec\x83yG\x14x\\\xde\x86\xfe\xff?\xfde\xa3\x9e#\x1b3c\
xb\xc7}\xcd\xd5i\xcb\xad\x1bd\xd9%\xf9\x14\x05\x04\x8d/\x0b\xbaX\xdb\xbb\x1c\
9\xf3\xf10\xa3\x8b\xbeO|\xfd\xf1\x03g\xe6/\xaf?\xbc\x7f\xc1\xae\xa4\xb4;\t\
\xabw\x1f\xfa*\xbcr\x87\xd3v\x97\xa5\xab\x99u&\x16L\xd5Y\x98~\xf4\xf4U\xc3i\
\x1av\xad\xac?\x95z\xae\xe7\xceo;\x9c\xa8\xba\xf5\xd7\x1e\xad\xf6\x04n\xcd \
\xb6g\xd7t\x9e\x9e\xe1\xdd\xbc\xf6\xca\xec\xacn\x93\xa2\x05\x9du\x99\xebN\
\x89\x1a\xc9>m\x0b\n9\xdb\xa8\xdcU\xb9\xe9\xd2:\xf6\xfa\xc6\x85W\x96Z~\xdcz0\
\xd5R)[cj\xf6\xaa\xc2\xa5W\xdf<\x9exm\xef\xe5\x00\xaf\x0b+\xf3\xee\xcf\xd0\
\xdd\xf6t\x9b\xb6n\xa4\xaf\x8a\xa1\xb3f\xe3\x9a\x9bG\xcf\xf9\x9cqM\x92\xed\
\x92\xdeu\x9d\x97gi\xd1:\x99\x1b\xbc\x8a\xbe\xb5\xdb_][\x90tk\xf3\xae\xb5\
\xf6\xad\xc7\rk$\x8d\xa7\xecz\xb6*\xe6Tw\xf7o\xc7W[Y\xbfT\x7f\xdc\x98\xaf4\
\xf9\xea\xdbgs,\xc3\xdfq\xb1\x97\xb76\xef>t0\xf6\xe1\x83u\x05\x05\xe1\x16;\
\xb4e\xee\x88\xf2\xe1\x13>\x9c\x95\x7f&x\x8b\xb5S\xcd:3\x87-\xd2\xd9\xbe\xc7\
=\x9eK\xb1W\xff\x9dQY\xbaN\x8aw"\xbf\xd7\xdacS\x13\xe3g-\xbc\xf2\x84Kd\xb5\
\xe5\xd7\xadze/\xcb\x97^\x9a9g\xd3|\xfb\xbbf7\x8b\x97\x99\xc6\xfa\x99$\xdf\
\x9b\xca\xa5\xf8d\xda\x0bk\xae$\x81\xfc\xf3W\xd7\xde\xbb\xd8\xd9\xec\xa7\x1c\
\xf4\x96\xc3f\x9b\xbd\xc0\xa5P\xf3\xf5{^~9\xfd\xe3\xff\x8d\xbd\xde\xf5}\xee\
\xf3\x0e)iO\xab\x8f\xedZ]\xf4\xd7\xa7\xfc\xba\xb4\x97`\xd5\xb6\x0b\xcf\x84/\
\x85\x8a\xef\xd9\x91\xb5\xe6LHVe\xe9n\xe1J\xd7\xe8k\xc7?\x14\x86\xea\xbe\xdd\
\x18\x9b\xa9owc\x9dR*\xcb\xc1\xddV\x05\xcf}N\x17\'X\xa7w\x96\xdd;6O\xbb\xb7\
\xff\x06\x9b\xc3\xf3\xfc\xd7\xc5\x1f6\x18p]<\xa7\xbf\xear\xf3B7\x13\x9b\x08`\
*a\xf0t\xf5sY\xe7\x94\xd0\x04\x00\x19s\x16\xad' )

def get12Bitmap():
    return BitmapFromImage(get12Image())

def get12Image():
    stream = cStringIO.StringIO(get12Data())
    return ImageFromStream(stream)

index.append('12')
catalog['12'] = ImageClass()
catalog['12'].getData = get12Data
catalog['12'].getImage = get12Image
catalog['12'].getBitmap = get12Bitmap


#----------------------------------------------------------------------
def get16Data():
    return zlib.decompress(
"x\xda\xeb\x0c\xf0s\xe7\xe5\x92\xe2b``\xe0\xf5\xf4p\t\x02\xd2\xee@\x9c\xc0\
\xc1\x04$\x0fT\xff8\x06\xa4\x98\x8b\x9d<C888n?\xf4\x7f\xc0\xc0\xc0\xe4\xe4\
\xe9\xe2\x18R1\xe7m\xcc\xedi\xcd\n<>U\xbf\xfe\xef\x7fc\xb7a\xab\x88\xa0R\xcb\
\x89\x84g+\xc5\xcbJ\xca\x14\xda\x18\x9e\xe6\xde\xee\xe8\x98\x99\xc9\xc9b\x99\
\xaf\x94\xf4\xecC\x1a#\x8b\xae\x8f|\xed\xe9\x86\x99\xf1\xe5\xf7\x0f\x0b\xecy\
l~\xf3b\xeb\x8b'\xcc{\xb8\x1cL\xd4\x0f&\xef\xe9r\x17_\x91/\xba\xdea\xfe9\xfb\
8\xd5s\x1c\xaao\xcf\xfe\xea\xbd\xba\xe8\x95l\xf8\xc6O~\xc9\xa2+\xebB\x0c?\
\xab\xeeJ~\xfclw\xe0\x92E\xed\xc7\x1c\x02\xfeT\x94\xca,~\x1aX\xbdu/\xaf\xa8\
\xec^\xa1\xa2\xa3\x07_\xbd\xd9\xfa\x81Od\xe5\xbe9\xbc\xf5jo\x16\tE\xb9\xae\
\x9aa,\xaf\xfb\xa3\xf9\xd9\xef\t[B\x96xM\x08\\\xfa\xe3\xce\x0e\xeel\xb7o\xa7\
W\x9dk\nu\x16\x08\x06\x8a\x9d\xd4M\xea\x12\xe8\x9eT7\xc3d\xc5>=\x87\x89Z\xc7\
\xcc\xd9\xc2\xda/H\xfe\xce\xb9\xb9\xd6\xc94\xed\xdc\x1b\xb3\xc9\x86\xb1M\x8f\
\xb6\x04M|\xf5\xfa\xeaF\xed\xf2\xb2w\xd2\x13\xcf\xeb\x8a\xb4w\xd9\xce\x0b|z\
\xa71#\xb0\xc7toQ\xa8E\x01\x12z17\xfed\xa2%\xbf\xc1\xa7S;\xa4\xd2\x17z\x95\
\x8b\xba7\x99\x1e\x9f\xba:\xab\xf5\x9dV\x1fKr\xf2\x83\x8eP\x99\x8b\xa5\xecA\
\xfc\x11G\x05\xe3\xcaC\xf8e\xb6w)7\xbas\xcb\xf4\x04\x99\xe6\x01\x956\xc6\xf1\
F\x1d\x9dx \xef\xfe\xda\xc8\xb2\xec\xf0\x89f\xe7\xf2z\xd3\x94\x8e\xa9\xe6\
\xf57\xa2X\xb2a\xf5\xddW\x8b\xe6h\xef\x0e\x17V\xd0\x0c\x99;u\xf5\x84s\xa6\\\
\xdf\x7f\x19\x16\xaf\x0fo\xe5\x9dh\x1e\xf4\xb5O\xfb\xe8\xcb]J\xa1\xc9\xfc>U\
\x9f\xf7\xad\xdfZ<\xbdn\xaaV\xcd\x8c\xb5,\xef\xcfJ\xa5\xffH\xbf\xfc\xb5-\xf3\
O\xe8\xaa\xdc\xdbI\x9e_~\xea/Q?\xfe\xe2\xd7\xb9\xba\xca\xc7F\xc5\xc6\xa1\x95\
,z\xbb\xed\x05\x82BM\xd7\xd9\xbc\xfc\xd2\xfdGj\xf3\xfbK\xf9\x87c\xfd\x1f:=\
\xbe\x97Qx=\xf3lV\xf2\x867fn\x7fn\xf8\xeek\xeai\x0c-Y9\xeb\xc9\x96g\x86\xdb?\
\xbc)\x93\x9aRo\xccj\x9a\xbc\xeaV\x83\x143\xf7I\xbd\xb5R\xcc\x8a{W\xd9\xbd\
\xbe\xbb:3\xa0W,\xbb\xea\xab\xd7)\x86\x17?\xf4k\xb9\xf8\xb9\x17+\x9c\xf8\xc9\
\\yi\xc32#\xa5\x8b\x91\xc0\xc4\xc5\xe0\xe9\xea\xe7\xb2\xce)\xa1\t\x00\x05\
\x9b)\xc6" )

def get16Bitmap():
    return BitmapFromImage(get16Image())

def get16Image():
    stream = cStringIO.StringIO(get16Data())
    return ImageFromStream(stream)

index.append('16')
catalog['16'] = ImageClass()
catalog['16'].getData = get16Data
catalog['16'].getImage = get16Image
catalog['16'].getBitmap = get16Bitmap


#----------------------------------------------------------------------
def get20Data():
    return zlib.decompress(
'x\xda\x01r\x02\x8d\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02*IDATx\x9c\xed[\xdd\xba\xc2 \x0ck\xfd|\xffW\xde\xb9\
\xc0\xcd\n\x8c\xdf\x1e!\xb5\xb9\xd29#1\xb4+e\xe3\xe38\x88\x88\x99\xc9\x04\
\x82\x9c\'\x111sxc\x00A\x0b\xd3\xa9\xcf\x0c\x98\xf9\xb1z\x0c\xff\x82gzH\xc6\
\x18\xa8\x8d\xb1W6\xd2\xc6\x87W\x97$P\x8b.d\xe2\n]\x12\xfdJ\\E\x00\r\xb3\x8c\
W\x97?\x8d\x92\x14\xa3Q\x8bj\xf6z%\x95O\x1a\xabH5\xa5*\xfd\xed\xe1\xd1(R\xd1\
\xbcW{\xa2\x92\x03A\xf1\xe1U\x1a\xa3\xe5\xa8\xed=\xff;T\x94z\xd5\xc8%\x93\
\xd5\xdd\xeb\xc6\x11(R\xbd9\x07\xbe\xd68E[h\x15\xa9$g>[\xf0\x89\xe1q\xb4\x9c\
\xa9H\x15!\xa3J\xf1\xba\xb1\n63{\xb7\xaa\xbbd5\x90\xc4\x14\xa9"|\xa8\n\xb1$)\
B.\x8a\xe6atB\xf5u\x01\x8aT\x12\xef\x1cX\r\xa1;\xf6\xdd\xaa[\x85n\xcc\x9e\
\xd5m\xa6b\xea\x82\xe2\xb2R\x91\xea\xedU:\x95\'\'\xf7B\xe4k\x0b\xe8\xb6\xcc/\
u9\t\xd3"\t\x9b^\xb9*\x1c\xb8*\x1c\xb8*\x1c\xb8*\x1c\xb8*\x1c\xcc\xae\xafh\
\xbf\xb50\xf9NOe\x1cwG\xbeOEV\xe3\xcaU%\x80\xd9\xe9i\x84\xef\xf4|\x89Jrv\xcf\
@\xd4\x9d\x1e\x03pUD\x84\xb8\xd3\xd3\x08\xa4\x9d\x9ea\xecV\xdd\x9a\xdd\xe9\
\xf1{\xa4q\xe0\xaap\xe0\xaap\xe0\xaap\xe0\xaap`S\x95B\xefv\t\xcau\xb0{\xb5\
\x01\xa2&\xd4]+\n\xa9fo\xbc\xd7\x8f\x99g\xbd*\xdc\x10\xb9\x90j6\xae\x14\xefK\
S\xa4\x1a\x9c\x81\xd1l\xbe\xeek\x9d\xec\xddV\xa9\xc2\xc1l\x97W>`5\xe2\xd5\
\xddR|`\x89\xdeKu\x1c\x87\x94D\xe7\xbf\x10\xfd\x89\xdd^uu\x14\xca\xcc\xc3T\
\xe5\x08\xf4\x15\xfeN\xa8\xe6\x15\xdf\x13\xc9\xfd\x86\xcd\xde\xed\xaa\xabp\
\xe1\xe4\xd9l\xb1j\x0f\xbfz2Xu+!/\xbb\xd1G\x909\xb0\n\x9b{\xf86\xab[\x85\xb8\
Z\xf5\x00L!\x9d@\xc6UU<j\x0e,\x14\xbb\x04\xea\x95Dv\x1e\xa2zU.D\xe0\xbd\xa2\
\\\x98\xa1zUN\x18\x16\xbcJ\xf1\x88\xda\x00\xe8x\xb5>\x1b\x1f\x16FA\x90\xf3\
\x07R\xe6\xe3\xa0\rK\xdf\xb7\x00\x00\x00\x00IEND\xaeB`\x82EG$K' )

def get20Bitmap():
    return BitmapFromImage(get20Image())

def get20Image():
    stream = cStringIO.StringIO(get20Data())
    return ImageFromStream(stream)

index.append('20')
catalog['20'] = ImageClass()
catalog['20'].getData = get20Data
catalog['20'].getImage = get20Image
catalog['20'].getBitmap = get20Bitmap


#----------------------------------------------------------------------
def get24Data():
    return zlib.decompress(
'x\xda\x01\x91\x02n\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02IIDATx\x9c\xed\x9b\xdd\x92\xc3 \x08\x85\xb1\xd3\xf7\
\x7f\xe5\xec\x85\xdb\xc4\xfa\x1f\x04\xe3\xb1|W\xedL\xf6$\x04D\x81\xad;\x8e\
\x83\x88\x9cs\xb4\x05\xde\x9c7\x119\xe7\xfc\x97\r\xf0\xb68\xfa\xd8\xb7\r\xce\
\xb9\xd7\xd3\xcf\xa0\xc2;\xfc\x92]]\x88\x9e\xfc\x01_yN\xe7\xe0&\xc6/\xab\xc2\
`\xf3&!\x86\x1f\xed\x1a\x81y\xab\xa0\x1dE\xd9uu\x97s\xf9\x8d\xbf\x05)\xa9\
\xd1\x08\x0c3\xca`v\x11\x94\xcaX\xd5\x1f~\xe9\xbd\xd9O#(E\xbf\x95-\xd0\x19\
\xb2*\x8dR\xf6*\x17\x94\xa2\xfa\xd9\xa2B\x98\xacJ\x9f;\x9f@P\xea\xd2d\xfcY\
\xe7:\xe6\xe5\x1b\xb6T\xa8Y\xdc\x85=\xec\xe7\xe8\xb9RP*\xa2\x98\xd9yr\x8b`9\
\x90\x88\xca\xc9\x8a\x91\xc4\x04\xa5"\xbe\xac\xf2k)\x94\xf0\xb9(\x8a\xc3\xe8\
\x82\xe6\xe7\n\x82R!W\x0el.\xa1\x92\xfaj\xa7[\x81n\xcc\x9a\xa7\xdb\xd1JD\xb0\
\x06\x13\x94\xba|\x95\x86\xf2`p?H\xfel!\xb8TT5K7\x9a\xb4_M\xde\xd9g\xf4\'&7O\
\xb7\xedH\x9bU\\d+\xc2\x1e\x04:g\x154*\xc2\xae\xfb*J+T\x84\x9d\xf7\xd5\x8a@\
\xbd\x8a\xb0\x07\xcb\x168hY\xa5W\x11\xf6\xa0\xe8+\xa5\x8a\xb0\x87y\x13\x9d\
\x99\xa7\xdbI\x93\x9e\xe8t\xab]V\x8f\xfa\xaa\xd2\xd2xJjt\xbf\xb2I\xcfT\xcc\
\xaa\x04\xa4IO\x0f6\xe9\x99$\x15j\xde\x8e@\xd4I\xcf\x06\x98UD\x848\xe9\xe9\
\x04i\xd2\xc3\xc6&=\xb3\xa4\x08m\xde\xd1\xc4:\xd2P\x98U8\x98U8\x98U8\x98U8\
\xe8\xce\x1a\xf5\xa8\x9f\x83\xcdW\x0b\x105\xa1J\xad(\xa43{\xe7\xff\xfa\t\xcc\
D\x16\x9c\x1e\xd0\xf8\xba\x12\x1c\xb1\tJ1#0\x8a\xe6s$5\xd8\xbbmJ\x9d\xbf\xcc\
I\xbb\xbc\xe7e\xcc\xaa\xb1T\x8a3J\xf4\xbbR\xc7q\x84&\xd1\xe7-D/\xf1\xb6\xafn\
u\x14\xea\xcal\xa9\xfa\n\xb4\n\x7f%\x9ay\xc5f"\xb9{\xec\xd9\xbb}v\x17\xce\
\xfe\x04\xd3f\xf8P\x98U\t\xcf\xce\xf0\xb3\x8b\xca\xb3\xe7\xe9V\xa0j\\\xf0\
\x070\xa8\xeb\xaa\x12~\x84kU\x1dH\xab\xd2\x82*\xda\xdc\xc0\xba1!\x95m\x1a\
\xd2WM }\xd5L\x95{\xfa\xea\x15\xb5\x01\xd0\xf9o}F\r\x1dt\xbc9\x7f6\xbf\x1f\
\x8d\xafP\xea\xbc\x00\x00\x00\x00IEND\xaeB`\x82\xa1\xb1=j' )

def get24Bitmap():
    return BitmapFromImage(get24Image())

def get24Image():
    stream = cStringIO.StringIO(get24Data())
    return ImageFromStream(stream)

index.append('24')
catalog['24'] = ImageClass()
catalog['24'].getData = get24Data
catalog['24'].getImage = get24Image
catalog['24'].getBitmap = get24Bitmap


#----------------------------------------------------------------------
def get28Data():
    return zlib.decompress(
'x\xda\x01\x92\x02m\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02JIDATx\x9c\xed\x9b\xd1\x9a\x84 \x08\x85a\xbey\xffWv\
/\x9c\x1c#SS\xa6<,\xff\xd5\xb4\xd5I"\x01\xa9\xe5\x10\x02\x1113\x99 \x9a\xf3&\
"f\x8e\x1b\x06\x88\xb60m\xf6\x99\x81\x99_O\x8f\xe1\'\xbc\xc5\xb6\x98`\xa0n\
\xdc\xf9\xea\x183@\xa3\x88\xf4\x15e\xfe\x015\x89\x84\xaf\xcc`\xd3*\x19\xd9\r\
D\x0bf~\x8b\xed\xe3\x11u\xc3\xd2)*\xf6k\xa9\x15\x9e\xc0\xb0\xd1?\x08\xd2\x08\
-\x8aj\xe3\xf3J7\r\xe8\xaa\xd9\x8c\x16\x85|\x85\x9b\xa6\x12;_\x1d\xe7Rev]:\
\xb8\x89\xae\x9a\xf4\xd5\xa5 \x11B8\xfb\xdd?\x02]\xb5\x8f\xe6\xf0 \xeatj\xea\
\xaa%\xcdr\xb4\xe0\x8d\xb1At\x1e\xa9\xab\x96S\xb0J7\x0b=\x82\xcd\xc8~\xcd\
\xaa\xb3H5\x16\xc1t\xd5r\xe4\xaaQ\x14~1\x16\xe5\xcf\xa1\xd8\xdb\xfc]GW-\xf1\
\x8d\x81\xcd)TT_\xb0\xba\x9d\xed\xc6,[\xdd\x16*\xa6~tW_\x8aj__\x1d\x1f\xe5\
\xc9\x87\xfbA\xca\xb5\x85\xeel\xb9\x99\x7f\xd3\xe5\x8c \xba(\xe7?\xf9\xaa\
\x9f\x05\xf3\x15M\xfaj\xd9|\xe5\xdd\x18\x1c\xdc\xaa=H\xdd\x98\x1e\xbc\x1bs\
\xabZ\xd2\xbc\xf6\x04\x02wc\x0c\xe0V\x81vcz\x00\xeb\xc6\x8c\xb1`uk\xb6\x1b\
\xe3\xdf1\xe1\xe0V\xe10\xb5\xc2\xd7\xfd\xe4DQm\xcaW\xbamPE\xb5\x91\x18(\xb2J\
z\x8d2\xbf\x12\x99W\xa3\xb1\x18x\x96U\xc6\xb2\x8d\xae\xda\xf7\x14\xbar3.]\
\xa0)\xab\xab\x96\xcb\xda\x8c\x81n\xd5h1~\x8fZ\x8e\xafD\x8e\'/\x99\x85\xa7\
\xa2\x85w\xa4\xef\xc6\xad\xda\xb3rG\xda\xab[\x10\xccVL\xb3\xef\x85\x9f\xa2\
\xbeNq_-\x80x\xc1u\xf6\x9a\x0b)Zt~\xeb\'\xff\xfbe\xf22\x8b\xd4\x81\xe4\xf9*;\
\xe7\xb9nL\xfcc\xf1\rr:\x0c\xaf\x1b\x13B\xc8M\xa2\xed.\x88\xfb\x08\xd9\x8d\
\xa9\xcf@\xb3\xb5\x05\xa4U\xcd\xb8\xe2\xdf[\x1c.\xe0\xdd\x18e\xb5\xca\xc1\
\xa8\xdd\x98\xe6\xc1`\xd5mN\x9ev\xc5.\xc8\x18\xd8\xc4\xbb1\xd5\xa1\xdc_\xdd\
\xf2Fa\x97\xca\x80\xee\xe7W1\xf0AR\x91\x9e\xeaZa$\xa4UMlZ\x05\x9c\xaf*i\x1a\
\xd2W\xcd4\x80\xea\xabz\xdc\x86\xf4U\x93\x97h\x03\xa0\xf3i}\x16\xe3=.\xd1\
\x9c?2Eg\x87o@\x00\xfe\x00\x00\x00\x00IEND\xaeB`\x82\xc3\xa7>q' )

def get28Bitmap():
    return BitmapFromImage(get28Image())

def get28Image():
    stream = cStringIO.StringIO(get28Data())
    return ImageFromStream(stream)

index.append('28')
catalog['28'] = ImageClass()
catalog['28'].getData = get28Data
catalog['28'].getImage = get28Image
catalog['28'].getBitmap = get28Bitmap


#----------------------------------------------------------------------
def get32Data():
    return zlib.decompress(
'x\xda\x01\xd1\x02.\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02\x89IDATx\x9c\xed[\xe1\x1a\x82 \x0cd}\xbd\xff+\xdb\
\x0f\x8ap\xe0\x18p\x8aC\xeeW\x89\x9d\xcc\xc16\x0e\xa2m\xdb\x9csD\xe4\xa6\x80\
7\xe7\xed\x9c#"\xffe\x02x[\xc8\xfd\xec\x9b\x06D\xf4\x1a\xdd\x87S\xf0f\xdf\
\xd9\x043\xea\xc6\x9d\xaf\xd2\x98a4\x8ap_\xb9\xc8?FMr\xccW\xd3`Ye\x07\x99yU5\
\x9d\xc2\xcd\x90h\x89b\xdb\xf9\xaa\x96+\xb6\xbf?\xb4\x00\xd9\xa4\xda\xc2S\
\xcb\xad\x0c\xcd\xef\x18\xc8&\xd5\x16v\xc3\xba{Dm\xc1 \x9b\x94\xb6\xf6\xbc\
\x02,\x1b\xf7\x95\x86+\x8eTG\x9f\xf5=\xc0\xb2}9\x9b;!C\xc9\x89e\x0b\x9c\xf9\
\x11H?\xb4uBy\'\x96-F\xc6*l\x16\x1a\x829+\xa6:\xab\x8e"U[\x04\xc3\xb2\xc5\
\xe0\xabF\xa6\xcc\xf8X\x14\x8fC\xd6Z\xfc,\x03\xcb\x16\xf0\x8f\x81\xc5)\x94e\
\xbfau\xdb\xab\xc6\xdc\xb6\xba\xcd\xacD\xf4\xc0\xd6S@\xb6\xbf\xaf\xd2\xa1\
\xdc9\xb8\x07"_[`g\xcb\xc5x\x8c\xca\xe9a\xd1E1\x9e\xe4+=n\x98\xaf\\\xa7\xafn\
\x9b\xaf\xda\xad\xc2\x8a\xf2X\xb69\xe7\xd5\xb2j\x0fKj\x8c\x06K\x8d\xb9\x94-p\
\xd6\x8d\xc0f\xfd$+\xef\\\xaa\xc6\xc0q\xbd\xbcs\xbaUC\xf6\x9a\x1f\xa0\xc6h`L\
\x8di\x83&\xfe\xea\xf7YPjL\x97Urwk\x13\x11j\x93\xa9\xd7*\x99Zs\xdbI\x8f>%\
\x06\x9e\x97\x88\x94X\xd5\xad\x1dt\xad\xf0\x8f\xe6w\x1c\x12\xe2+\xd9\xebE\
\xb6\x06t\xf9J\xc8*\r\x89\x08(\xaa\xb6\xc4@\x16\x9a\xc36\x8a\x90m\xf4M\x1a\
\xb6b\xf7\xaa}uT\xaa\n%lCSgA\\\xe7\xab\xaa\x07\x14i\xb1l1\xed\x9c1pY\xd5Z\
\x8c_\xc3\x16c\xadD\xd2\x1fC\x8fr\x01k\xf6\xa5H\xdb\xc1\xb2j\x8f;+\xd2gU\xb7\
c\xd9\xd6?\x95\xec\xa0w_x\x14\xe4u\xca\xf2\xd5\r\xc0t\xc5#u\xd1R\xb4P\x9e\
\xf5#\xa2S\xd4\x98\xe1l+_\x85\xdf@\xf5\x93*\xb6 \xa1\xa7\xc2}\xb8\xed"5\x06\
\xc8\xb6m\x1b\x13\x15\xfd[\xe0\x1b\x11\xce\xa0\x1aS\xdc\x8b\x993_\x99\xb4\
\xaa\x18W\xd6y\x8b\xe4\x01K\x8d\xc1\xb3\xb1\xd8\x18_\xb7\xaa\xc6\xc8\xad\xc6\
\xaa[\x8fb\xba7\x19\x03=\xa4\x13\x0er\xb3\x8cQ\xf3*\x1d~\xb0y\xe5\xba#\x15\
\x90\x8d\xd9\xd9;\xaf\xb0k\xb3*\xb6\xb8\x9ceM\x86\xe7\x95\x80e\x95\x1d\x98\
\xccW\x1eB"6\xe9\xab\xa2(o\xd5Wr\xb44\xe9\xab"^\xe9\xd9"\xd3\xf8J\x9fL\xd0\
\xb1\x0eo\xce\x07[\xc0\x94\x88\xec9\x9c\xb0\x00\x00\x00\x00IEND\xaeB`\x82\
\xe2\xf5Z\xf2' )

def get32Bitmap():
    return BitmapFromImage(get32Image())

def get32Image():
    stream = cStringIO.StringIO(get32Data())
    return ImageFromStream(stream)

index.append('32')
catalog['32'] = ImageClass()
catalog['32'].getData = get32Data
catalog['32'].getImage = get32Image
catalog['32'].getBitmap = get32Bitmap


#----------------------------------------------------------------------
def get00Data():
    return zlib.decompress(
"x\xda\x01\x0e\x02\xf1\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\
\x00\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\
\x08\xdb\xe1O\xe0\x00\x00\x01\xc6IDATx\x9c\xed\x9c\xc1r\xc3 \x0cD\xa5L\xfe\
\xff\x97\xe9\x81\x96!\x180m\x83\xe2'\xeb\x9d\x1c\x0e\x89w\xd6,\xb2\x82\xad)%\
\x11QUqA\x96\xf3\x14\x11U\xcd\x1f\x1c\x90\xb5\xa8\xfc\xe8s\x83\xaa>>}\x0e[\
\x18\xaaB\xcf\xb4;y\x95\x8d\xe2\xdau\x1b\xaf\xb2E\xe8u\xec\x1e^\xd5Fq\xedzvG\
\x89Jj^\xbc\x1a\x89\xc1\x89\xecx\xd5\x14P8IR{U\xce\xbe\x96\xd1\x1d\xbc>>30jv\
\x0e'\xc9\x0e\xb5qX1\x1d\x8fA\xf8\xbc\x02o\xa0JU\x9b\xceLJ)\x0f\x9a\x9f\xd8\
\xbf\xf8\xc5M\x07%9\xdc&\xbbwU\xcdt\xea\x8eP\xe8WL\xe8U\xd8\xed\xbc\xeaWLD\
\x8bj|z\x15\xaa8\x84*\x0e\xa1\x8aC\xa8\xe2\x10\xaa8\xf4\xeb\xc0\x1dX\xde\x07\
\x18ye\xdc\x8d\xb3Pu\x94\xb1[\x98\xcfy\x15\xaa\xfe\xca1\x1ev\x07\xc6\xde\x0c\
\xacsot\xbc\xe5w7~\xf5Z$\xbc\xfd\xd77vc\xd6SnG\x1eFZp\xd8\xa5j\x94{6y\xb8\
\xd1\xabQC\xdb\xa0\xd1m\xf7\x1f\xbeYuk\xd7\x916\xaen\x8d\xeeD\x8c[\xdc\x91\
\x81\x1cB\x15\x87P\xc5!Tq\x08U\x1c\xecz\xb7\xefe^+\x87W\x17\xa0iT\x8d\xdaU\
\xa4=\xd2\x8b{\xfd\xdc\xee\xf8\tU\x9f\xa6\xcc\x94n\xe7\x83:\xaf\n\xcd\x04;>\
\xaeC\xf2j\x9dPu\x19N;\x8a\xb0U\xb80\xcf\x02\xa4W\xa7\x90\xbc\xaa\xa3\xafx\
\xd5\x1d\xf4\xe9\x15I\xd5\xfa*L\xba\x02\x0b\xa7e.\xc9+\x19G_3\x8e\xf4J\x06iQ\
\x80y%\xaf\xcfU\xd5o\r\xa8\xe1\xa9Z\x01\xa9\xaa\xb6\xebF\xdd\x18\xaa\xaa\xd1\
\x8e\x80\x0cU\xd5\x1c\xb0\xaaI\xd9\x0eV5\xe1Q7\n\x1d\xf0\xdd\xfa\xe4\xbe\xf2\
\xa6K\x96\xf3\x05\xdf\xb6\xe4\xb2Kj\xdch\x00\x00\x00\x00IEND\xaeB`\x82q\x8e\
\xf1&" )

def get00Bitmap():
    return BitmapFromImage(get00Image())

def get00Image():
    stream = cStringIO.StringIO(get00Data())
    return ImageFromStream(stream)

index.append('00')
catalog['00'] = ImageClass()
catalog['00'].getData = get00Data
catalog['00'].getImage = get00Image
catalog['00'].getBitmap = get00Bitmap


#----------------------------------------------------------------------
def get40Data():
    return zlib.decompress(
'x\xda\x01\xbc\x06C\xf9\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x06tIDATx\x9c\xedZ[\x92\xe3 \x0c\x94\xa6\xf6\xfeW\xd6~\
`D\xab\x116\x10\'\x9bdG5\xe5`\x8cAM\x83\x1ex\xd4\xccDDU\xe5+\xa4\xc0\xf9#"\
\xaaZn\xbe@\n\x16\x95\x8a\xefkDU\x7f\xfe\xb5\x0eO\x91?}\x15\xee\xb1\x0f\xa5\
\xf1;\xb9JP9?\x1fJ\x94\xfcG\\}\x81\xfc\xa2\xfa\x1cI,{/o\x15O\xcd\xd8\xb0\x86\
\xaa\xa8>zgT\x7f\xbcU\xca\xb5\xe0e\x8d\x8f\xf2\x06+\x96vr~gW\xe0\xa8\xbb#8.\
\xe5Z\xb8\xeem\x0cI\xabL*\x96\n\xa3\x1a\xf5hW\xf3\x84\xc04\xd6\xf7\xb7\'\x90\
\xd2\xf2\xaa4T4F?d\nLU\xc5`a\xc9qg\xb1L\xb7\xa9\xbey\xe7[\x12\xac\xc5\xe5\
\x12\xb7Q\xda\xa2~\x99\x95\xa7\x06.S6Ph\x15!0dilQ\xccDU\xf0\xfaTaTNz\xb7 \
\xbdA{t,\xbf\x9b\xc4\xcch\xc9m\xf3\x19P\xd1f\xc5N\xcb\x1c\'\xa2exQ\r32\x9a\
\x9dTF/.u\x822k\xd9\xd3n\xcd,1*\x03\xcdF2\xb2{\x8f\xd8\xc3\x86\x8a\xc8!\x85f\
\xbaE\x90^>\x9f\xe6yu\x97\x80\xfd\xe0;\xfd\xf4\xc0\xac\xdf0\xd8\xcbd>\xb6H+\
\xf5=\x13\xcb\x87\xf6U*=\xed\'\xcd\xd2myR?)?\xf4\x0eu\nF|D\x17\xd7X\x95\xd1\
\x90\xc5\x9c\x9a%\xc0f\xca3\xd2,;\xc6\xa9}\x90\x96\x84\x13u\xf9\xe9a\xdc\xed\
8a\x1c\x9b\xe3\xda\xb2\x95\xfb\x96N\xf5\xf9\xd4\xcc\xa2\n#w\xee\t\x15\xa2\
\xfa\xaae\x0e&\x9e\xc3\xb5\xae\xf0ip\xeb\xf0\xe86T\xe3\xfc*\x7f?\xd0\x95\xf8\
n\xc5X\x96\xe6\n\xe9\x9dq\x03\xf32\x1b\x07\xa2\xf8\xf2h\xfc`&\x82\xe4\xb4J\
\x9e\x17~\xfd4g\xf5q\'5\x9c\x8en[l\xda\xbe\xa1xz\x8b\xa3y\xf2\xdb\xf7@*b\x98\
k\xa0w\x8a\x8d\xda\x9f\xcb\xbce7\x8ck\xdd\xb4P\xdeN\xb9\x96\xc2\x95"\x8fl\
\x0c\xb1\xca!\xd1\xb2\xea\x18\xe7\xb9\xa2P\xc3$\xe5*Z6\xd7.0|l$\x86t\\\xebN\
\xeb\xcd\xcc\xbc,p\x958\xb1+\xae\xd0\x06\\CR(?&\x0b\xa71\xbd69W\xda^\x911\
\xa4\xe0\xd6\x11\xcf\x1dq\xe5\x02W}\xe5\xf5\xbe\x82ukq\xb3\x97\xf0"\xf4%\xf7\
@\x92\xa5}\xd5\xe3\x9a\xdaW\x00I3G,\xd9\xbb\x0f\xca\x9a\rl\nT\xf7\xca\x07F\
\xc0\x15\xfaV\x05HR\x89\xcaw\xd7\x1d\xb2\xc3\xd5\xb1\xae\xd230\xe4\xaa\x02\
\xc3\x08cx\x1a\xd3l\xe0\x92\xfe\xb9<\x94\x89\xb0\xf3\xadD\x15Z\xd4\x81\xd5\
\x1a\x81k\xe0\xea_\xd9@\x92<M\x08\x06\x10\x80I\xe3\xa7\x98>\xffk/J\xc3\x86\
\x91\xd4\x1e\xc6\x9d8\x10wK\xb0\x8d0\xe5\xce\x89G\x80xu\t\xc0`\xf9\x19\xfe\
\xac\xaf\xc9\x1dT\x12\xf3\x9f\x16\x04\x04sR\xf5\xabF\xef$\x8aS\xf8\t\xfc\xec\
\xee\xb1\xfd\x98\x9d\xae\x87F\x12\xb8rI\x89\x92cA\xaa\xcf\xce\x83\x14\xb9l\
\xae\xc0\x04\x920Wf"\x1a6\x95\xf8\x9a\x14\x11\xc8\x00\x04!A?\xdb\xb8\xee\xe1\
\xaaj\xda`\xb8Z5\xb9\n\xda\x17\xcf\x90\xc4+\xc0\x92\x87\xc5\x1b\x87s\xf7pe\
\x92\x11\xd5\xac\x05\x9f\xe6\xf6\xa7\x00-^\xae\xbf{x\x8a\xdc\xc0\xd5Q\x1b7\
\x15,9\xc3\xd5E)\xbd\xa0\xb1\tlw\xfd\xaf\xc8\xa6\xbf\nakTH\xea\x92\x9bH\xd7\
\x0f\x07\x97\xf5\x10\xd2\xb9U\xd9A\x85YS[9@\x0e\x1f\xc8\x989\x02OF8\xcc\x8d=\
\xd0uU6\xfd\x95d\x86X\xa3\x12\xedl#\xae7\xeb6\x1ev24\xb0+\xb2\xb9\xaf\\\x8d\
\xa2J\xda&Zv\xb7\x16`/\xc1\xc95\xbb7r\x86+\xb2e\x03\xa9T\x15\n\x84\xd4\x18\
\xfc\xf8\ri\x7f+\x10Qr\xe2\x0cWd\x7f\x05\xba\x1e\xfe\x1bO^\xb9-\xc6\x84\xfc\
\x942\xb7\x18g\xbe\x88+\xa6\xc8\x8dXu\x9c\xa3\x83.\x8c\t\x8b\xa4\\I\x8c37d\
\x0b\x15\xf8\xfeC\xba\x9c\x8f\xe6\xd7\xf0\x1b~\x1f\xec\xc6\xc6\xf8\x01\xe1\
\x85\xd6"\xa8k\x1dk\xa5\x9e\xdfj\x90\xa4\x03\x86\xe4\xc7\x0f\x08\x1b\xea\xc9\
=\xffI\xd7i&\x90\x1d\x8a\xb4k\xcd \xad\x01\xf3\x1e4NV:\xce4\xc6\x9b\xfe?P\
\xe1*"1\x87\x0f\xc1\xae\xdb\x80\xd6\x94A8\x9f\x12\xec\xea\x82G~\xcc\x06\xa2\
\xf0\xde8\n\xcdB\xc8aH\x84\xf6\x0c\xed@H\x8b\xe39\xc2\xc2\x82\xbc\xef\x7f9\
\xbb4\x11\xc3"\x84\xc4\x194\xeeF\x80D\xb2\xc4\xd5M\xa8\x0c\xaeU\x890\xb3\x11\
R\xd0\x0f"@\x8d\xcb\x8f\xe4\xb5\\\xa1\x9d\x00\x1b\x08\xde)a\xa9\x01\x9b\xe0j\
&\t@y\x96\rDmzHa\xd6O\xb9\xf2\x96\xfdG\xad\x13Y\xb3\x16\xb4\xb8\xeb\x87\x12\
\xf0D\xb1\xb1DfZ\x14\x9f%\x8b\x92q\x15c\xcbY\xa7\xbc\x80\xaa\xdf\xafA\xd7\
\xd3\xe1\xf0\xe0Rh\x8dE\xda\x10X8~Z\xb1\x81K\xdf\x85\xf3eM<`\xfbJT\xab\xe4nK\
\x0f\xde\x15x\xbe\xb8\t\xcb@\xb3\x8ex\x16\xd5\xe5N\xa53=Z-G*\x85A\x13\xe5\
\xcb\r\x0cT\x9a\xbd0f\xaf\xa3\xe2-\xa6\x0f\xd9\xd36\xcd\xda\xcd\x11\xb1\x8aA\
=\x0cw\xa6\x03u\xb8o\x03\xf3\x0f\x08\xf1\xdc\xc2\x8e\xffW\n:\xa1\x01@\xcbV\
\xd9N yW\xa9\x0e\xfd:Z\xe6\n\x95\xc03\xb0~\xda0AL\xb7\x04\xcd\x85ge\xf5\x95\
\xa0+\xbdNN\x8fn\xd7\xb8\x1a\xa5\t}\xd9\xcc\nE\'\xfb\x91\xb8r\xb9\xe4\n\x9dX\
\x7f+K\xa8\xfa\xe1G\xa7v\x1c=\x0cd\xf5l\xec\xe5\x99\xc8\xad2\xf2"\xf3\xf9\
\xfe;\xa2\x1a\xb1\x07\xd9\r\x93L5\x0b\xa8\xe6\x97\xca\xc4Yt\x88\xeb&c\xbcx\
\xfcF\xfe0|\x91X\xe3\xea\xc4\x9a\xa7\xe5Q\'h0\xd3m\x99\x82\x9c\xdfW\xcb\x96=\
\xf9\x96\xd1M\xd5|\'\xd4\xa1z\xb8\x9e\x01 \xf7@\xb3\x83-\xf7\xbf\x0b\xf75\
\xdb\xc7w\xbd\xd0\xdc\x8dX\x1a\x8dx\xdf\xb9\xc5@\xe8\x98IfRZH\xb0\x8c>\x7f\
\xcd\r\xfaDT\xfc\x91\xe1\xb2\xfd\xa05\x01\xeb\x87\xf0f^\xbe\xe1\xbfHF5\xe2i\
\x12\xe4\x17\xe9-\xa8)\xe9\xf7\xe2p\xd2\xe6m#\xe7x{\x7ft\xebcx\xfe\x87\xcf\
\xd2[\xca\xb2F\xc3\xa5\xcb/=\xcfx\xc8\x0b[\x15\xaaGHS\xfd\xd0\xd9\xc7`\xe3\
\xdd\x7f\xca\xb9\x9a\xba)\\\xd3\x9aQ\x83\xbd\xe1v,\xfb\x8d&\xfb5\xf2\x8eq\
\xe0\xe3\xf2\x8b\xeas\xe4\x17\xd5;I\x9f\xd5\xa3|*\xaasyzt\xfb$9w6\xdf\xc9\
\xd5\xcf\xf6\xd7\xff\xf7\x94\xe3\xd3\t\x7f\xcf\xfcp)p\xfe\x02\xb2\x95%fW\\.w\
\x00\x00\x00\x00IEND\xaeB`\x82\x1d\xcdOE' )

def get40Bitmap():
    return BitmapFromImage(get40Image())

def get40Image():
    stream = cStringIO.StringIO(get40Data())
    return ImageFromStream(stream)

index.append('40')
catalog['40'] = ImageClass()
catalog['40'].getData = get40Data
catalog['40'].getImage = get40Image
catalog['40'].getBitmap = get40Bitmap


#----------------------------------------------------------------------
def get48Data():
    return zlib.decompress(
'x\xda\x01x\x06\x87\xf9\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x060IDATx\x9c\xe5\\\xeb\x92\xdb*\x0c\x96v\xf2\xfe\xaf\
\xac\xf3\x03\x10\xba\x01\x02\xdb\xdbu\x8e\xa6\x93b\x07c}\xe8.\xd2"\x11\x01\
\x00"\xc2WP\x81\xf3\x01\x00D,\x17_@\x05\x0bB\xc3\xf75\x84\x88?\xff\x9a\x87G\
\xe8S\xfe\x92vED\xe6\xf2\xb7\x99\xbaL\xdf)\xab\x8a\x8a\x05"%CDo\x14\x14\x84\
\xb2*\xea\xf7R<\x85,\xaa/\x80\x04\xa1\xac\xde\x0e\t&\x1a\xf8j\xfa\x98\xeb\
\xe2\xd6M\xb6\xf1\xa7pfT\xc9\xa2\x82\x01\xb0]\xb5DD~\x02\x11\x96c\xf7x\xfc\
\xc6\xe4\xfe\xc6\xf1*\x99\xf2b\xa3p\x85r;\xf3)\x070\x86\x94\xa7\x1f\xe6O\x0e\
\xcceH\xf2\xab\t0\x82\xfa\x07\xc6c\x83\xf3\xba\xbb\n40C\x1eF\x98\xf8\x9b\xe4\
kD\xfc\xd8\x04\xd2Va\xf1\xe1\xd7\x1bn\x92\xcf\xdfBK\xdcF\x83\x96t(\xab$\xcdc\
z\xad\x85\x12\xd6[\xa6Q\x02\x7f\xa1 \xb7\x189\x00I\xa1\xb2\x85\xdcd\x98\xb8]\
5\x94\xac\x8c\x03\x98\xfbV\xb9\xcdf\x9cy\xc4S\xd2\x083\xb4W\x89\x8c\xfc^f<G~\
/uT>\xec\x9a\x9d\xcbo\xa4\xe1^V4<~\x14\x98\x8aW~\x9b\xffT\xae\x94\xa7\xaf\
\xae\x8534\xf2{\x19\x7f\x08\xbf+\xfc\xb8\xc2\x0f\x0b~s9\x1fK+\xe5\\\xb9\xd0<\
rd\xe2\xca\x92\xbag\xaf\xdc\x94\xa5\xc7\xd6\xec+\x14\xe6\xd8\xf3\xa7V\xce9@\
\xbf)\x07\xe44\xd0\xe4\xd2c\x9ag\xb7^9YV\xe1j5{\x10\x8e\xf7\x8a\xc4\x82\xaa1\
\xf9\xe4d\xe6<\xf7\r\x13%)\xf6\x9ag]\x00v\xbf\x0f\x1c)$8.\'\xedTj\x9fgZ\xf8\
\x94g\xcf\x18\x86\x9c\xa3$\t\xa7h\x1a\xdd\x96\xb3{9\x80L\xb79\xe9\x16w\xa0a\
\xe8\x8eD\xfduNWQ\x85\xaao\xb3d\x96@\xb3\x16F\xc27AV\x19<\xa2\x8c\xdb\n\xe8P\
\x03\xb9`a\xd5\'\xea\xad\x15\xa1W\x95I\xb9\xfb\xdef\x90\xe7h)\x1dW\xfb\'\xa8\
\x18\x0c\xbf\x90Z,\xa80\xbaw\xee\xc0\xc2M\xe7\xfb\x16\x12\xcdb\xe6\x92\xb6+\
\x91f\xcd\x04\xfa\x93\x9bJ^b\x00\x01\xb6\x8e\x87\xdc-!\xa53\xe7\xbe\x81J\xbd\
 j\x82\x85\x12+\xe2Rm@i8\xe5+\xf9\x1a!\xa5\xe7\xe3\x95|\x81\x13\x14\x7f\x1a`\
\x86\xccM\xd2*\xd7^\xc4/<\xcf-\x8e\xbc\xc5\xaagY\x81\x89\xe9E&Rb\xfd\x0e(\
\x8b\xbabNL\xa7Qx,\xae\xca\x1c\x02\x90\r<<E\xcf5N\xa3<\x8e\x00\xe7q\xeb4^\t\
\xe1\xa0\x18\x93\x88\xa7U2\xbd#\xdb\xb5x\xd8\x03\xc3\xc9\xd5\x06eQa\xf7\x01\
\x1c[\xa8\x00\nOOjE\xa3\xc1\x80\xf4\x90mB\xbd\xc0\x1asM6x\x06,\xab\x81\xd2\
\x1e*\tH\\\xea\xf5\xf8;\xd0\x9fbK\xa5\xb7n\x8d\xca\xf9\x89cYeQ\x99\xc3\x0bT_\
\xd5\xa0\xac\x12%-.9 \x02\xa0\x99QEo\xdf\x03\xb8aW\xb8\xa3\xf4N\x00j\x9dX\
\xb5\xdc-S\x17\xe7\xb1\xedtc\x06\xbbID\xe8<2F\xe2j\xf3\xb5\xac@\'\xb9b\xd9\
\xbe\xfef3cGV\xe1M]#\x8e\xde\x1dE\xb5Fc\xb1\xb2\xad\xee\xcaj\x03\xd5H\x1fT=\
\xdb\xd83\x8eq\xc49\x02\x90\xa8;\xcc\xd7\xc7y\xd3\x96]\xc5\xf5y\xab\x02\x15O\
\xf3S\x02?\r\x81#[\xdf,S)?(+\x10\x8a\xa1\xbe\x16~\x8c0\x90I\x1f\x9b>\x8c^\
\x1c"-\xd8\x15\xd7^\xcen\x14]\x91S\xb2\x92\x19E\xe9\x94{t\x10\xf4\xe4\xda[\
\xd9\xd3^Gz\xd6\xafC\xf1Y\'\x00\x9fd\xf3\x9d\n\xcf1\x1a\x06=\xb9\xf6\x96\xb0\
\xb2\x1aHK}\x08l\x9d\x1f\x0c\xb8L\xbdQ/\x95W\xc3\xbd\x9c}V#\xb0]\xf5\xbc\xbb\
\xcb*\xc80LE\x1f\x05\xbd\x1a\xc6|\xb2\xb6\xa2\xc3J\x84\xd7\xefL\x08\xbbB.7\
\x84i\x19\x92J\xe5\xe3R\xcd\x9e\xeb\xb7`\x06K:\xfd\xbd\x85\x1c\x17&\xb4]q\
\xe1\x18gL\xad\xb0\xef)\xbb\x0bz\xc0}\xe9\xe9j!]\x95\xd5\xe0\xda\xca\xca\xb4\
.\xa0\x00\x13\xb3\xa9\xc8\x8a\x85?w\x9a+:\xed\x07vf\xe4\xb56*\xae;\xc2\xccX\
\x81t\tU\x9c\\e\xe9j\x9f]fC\x00\xca\xa8\xa4=xq\xb5}i\x0f\xaeZ\x06[t\x8e*\xf4\
\x13LV8\xd1\xa6s7\n!\'\xae4\xc2S\xbb\x92\xceJ\x82\x01\xdb\x9f\x90Z&\xc5\xd5V\
\xa8\xdc",\x04\xb5\xd5x:A%\x92w\xbee-J\xe2\xe1\xb1\xce3P\xcd\'\xd5\xd5\xe1O\
\x1c%hS:?=0R\x02\xf4.C\x91\xc4&\x02\xab\x93X]\xac\x1d)\x1c\xd9\xd5I\xbc\xf2u\
\x07p\xe3I\xb0\x05-\xc2H\xbb\x93\xf1\x07\x9c\xc4\xfa\x83\xd7\x1a\x9d\'\xa8\
\xba\x94\xb8H\x94\x0c\x89=V\xe7q\xbd\x12\xeb\xa7r`\xe2\xef\xe5\xaem\xa1\xcbg\
\x8dhwW\x9dXk\x18\xc1A#\x11\xdc\x07\x86\xe9Z\xbcB\xa5\xfaa\x19;|\xf4\xc9\x7f\
\xcavdW\x00\xe0\xb22\xa3H\xe11\xb1]gP#^\xa7#\xbb\x12]\x84\xd0T\xe44\x1a\xc7\
\x1c\x8f\'\xb3\x17\xe1|3\xf3\x86\xdc\xc2\xff\xac\xc5\xbf\xdb4\xf4\xda\x81\
\x9d\x9d?\xd9\x82\t\x0f~\xe6%o1AR\xc8\xe8\x98\xd9Z_\\s\x13\xc1L\x18Iu\xd4 \
\xba\x9a\xdd\xce\x03?sY\x0f\x94u?\xd4\xf7\xc32cp\xdb\xe1w\xe77~\xf58q\xdf^\
\xd4#\xe5\xdcj\x9e\xfd\xef\x7f\xcb\xf9wh\xe4]o\xb3\xab\t\xb1.I\xbd7\n\x96\
\x0fV>*\x18\xc3\x93\x13\x9e\x95\x95\xe4~\x94\xef\xed\x8e3\xf4\xd4o\xce<+a:;\
\xf9j\x99R\xc9\x9d23o\xfe\xd7/IO\x15r\x1c\xfa\xbd%\xb0\xf0\xfe\xc6\x19~\xe65\
\x92\xbf\xe4a\xcf\x13\x94\xee\xb3G\x99\x9e\x9a\xd0\x06\x87\xcd\xae\x1d\x9ad\
\xd2\x85\xc3\x93\xf3+\xff\x0e\xd3\x81\xc9\xb0\x15\x1c\xe7\xe42\xfd\x0c\xdd\
\xd1\x0f4M!\x12G\xdd\x83q\xef\xbdhJ\xfa=\x99X\xfb\xcb\xab\xa8T\x9bI\xf4\xb9\
\xe6\x1dK\xfe\x1c\x01\xcb4\x95|\x0e\xa9\x18\x83\x84\xa0w\x0f0\x1f%\xc9\xad\
\xac\xf1@@}\xaa\x1a\xfd5\xf2\xae\x02\xbf\xe0\x7fX\tE\xf2zT\xa1u\xbc\x1b\xd5\
\xc8\x82^\x8cj\xe2\x14^\x89*\xec\xed\xc8\xc1+Q-\xe9\xf5\x9e\xdd\xd37x\xf6\
\x90~\x96=\xbdwQ\xed\xb7\xce\x13\xaa\xd7Q\x81\xf3\x1ft\xab\xccUF\xc0g\xb4\
\x00\x00\x00\x00IEND\xaeB`\x82\xdf>\x13\x96' )

def get48Bitmap():
    return BitmapFromImage(get48Image())

def get48Image():
    stream = cStringIO.StringIO(get48Data())
    return ImageFromStream(stream)

index.append('48')
catalog['48'] = ImageClass()
catalog['48'].getData = get48Data
catalog['48'].getImage = get48Image
catalog['48'].getBitmap = get48Bitmap


#----------------------------------------------------------------------
def get44Data():
    return zlib.decompress(
'x\xda\x01\x8f\x07p\xf8\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x07GIDATx\x9c\xed[\xed\x92\xdb0\x08\x84\x9b{\xffWV\x7f\
H\x82\xe5C\x0e8\xb9k\x93)s\xe3&\xb6,\xb1\x02\x16$\xa5<\xc6 "f\xa6\x8f\x90\t\
\xe7\x9b\x88\x98y~\xf9\x00\x99X\x986\xbe\x8f\x11f\xfe\xfa\xdb:\xfc\x88|\xe3\
\x17\x17]\xefkC\xb5U$\x8c\xf7\xa5\x90o\xf7]\xec\xf3\xbe\x90\x08m\xf5I\xf2\
\x1f\xd5\xfb\xc8g\xa2\xf2l\x91\xca?\xc5\x1c\x95|SBED\x0f\xbab\x9a\xb8\x07\
\x11\x8d\xb1\xca\x96}\x9d\xaa\xbc\xa4.+\xceo\xd5\x03\xbb\xd6B`umf\xcb)\xbd\
\xf1\xacxT\xa7N\xc7\x18q \xe6#Z\xcc{u\x13\xe1\xb8\xcf\x00STqlw\'\x056\x06\
\xd1a\xf4\x89\xa7\xee{/,n\x8c\xad\xc6\x96b\xa7\x02I\x83\n\x14\x92~$\xba~\x8d\
u\xf2\xb8:Mmj.\xd7"\xed\xe1\x97\x0be\xcf\x812\x9d\xd7z\xccV\xb3I\n\x13\xa9On\
\x8e\xcb0s\x8d\x1f\xeap!\xc6V\xad`u\x11%\xe3;\xbd\x8b\x115\xc5\xbdx\x9b\x0f{\
\xb5\x053\xcfq]D\x89"\xa8\x13&\xab\xc5\xef\xdb\\\xae\xcf\xd6\xe7\x8a\x98\xf5\
U\x9c\xaab/\'C=\x94V\x1e\xabw\xfb\x85\xef\xc4\xe9qw\xc6\xd89*R_\rLj\xae\x97K\
\xbd\xb6`Q{\xfe\x1b}\xcf\x19*\xce\xcb\x80\x0f?\n\xac\x8ajr:\xb3\x87ta \x97\
\xfd\xa4\xbdX8u\xd7y\xe7aIp-_\xee\x1d\xd7\xe9\x88\x04\x10!\x89\xa1\x82\xc7\n\
\x83\xad\xab<:\x00\xab|\xae\x88\xe6+\xa1\xa9y\xadf\x15t9\xabhZ+\xf16\xd7\xfc\
\x10\x81\xc9,D;\xd7%x\xe0\xd4\xf8\xec\xf4\x9a\xa6\xc3\xcd1\xf6\xa4\xd8T\x8e1\
)\xc0\xc8Z\xccuN\xcf\x05\xdeq\x8f)\x15\x0fI2\xd2\xd2\x8e&I\x8eaIb\xec\x80\
\xdchR`\xcf\x18\xc7I#\x0b\xa7\x90$\xd8\xc4\xb7\x94\xe8 _{H\xf3\x15\xc0\x96\
\xc6\xe4]PT\xdag\xf7\xb5\xdc\xa1\x19\xaa\x1e\x1e\xac\xfb\xe9\x13\t\xb6\x01\
\xc4#\xdd\xb8\xa8\xabh\xdb\xab\x98\xa6\xdec$)w\xd1#\xf2\x80\xfc\xd1\xe2\x07\
\xd1{_\x93\tZ\\j\xe9\xa4\xa5$\xd5\xf7-H*tV\xd7b\xd6\xd9%\xa9Gi\xb9\x1c&\x007\
\xebR\xa6H\xc8\xb1p\xe6~e\xb5\xbcU\xb9\xd7\xb3\xb0~\x10\x9at\xac\x80\xd4\x87\
\x06C\xd7\x12\xb64]\x81\ry\x1b\x8a\x00j7\xcc\xca\x1e\xc8\xfa7\xbc\xc54\xcf\
\xfayu\xdf\xc4\xf1l\xfa\xc0\xd9\x91\x8aD\xad\xb7}\xbe\x0e\xec\xe6.\xe7\xb0)\
\xed\xe8#V\r\\\xc80;\xc8:;\xb2\xd6\x92\xf6\xabX+\xbbb#\xae\x9c\x080ep[\xd12D\
\x94\xa6i\xce!\t0\xd1|w\xb5\x87\xebDW\x19\x15*\xb4\xd5Z\xf4\xb6\xb1\x89[n\
\xb5\x84$\x9c\xea\xab\xc3\xc8\x80\x00\xc9\x17\\\xad\x95[\x15\x95\x87\x14f\
\x1d)\xc4\xa9h\xc08\x183TwW\xaeMk\xe5\x8a\xd2\xd8\x91\x96\xb1\x89\xecu\xeb7\
\xff\xb9Vc\x1c\x1a\xe0\x1agCeLn-xm[\xd1\x81\x1b\xd6\xa3]\x1c9.A/\xa5]F\xad\
\xa7R\xefN\x0c\xa0~\\w\x16\xa5m+\xc4\x80O5GS\xa4\xbe\xa3\x89h%%b\xa6\xb1\x07\
\x18`\xb1\xfa\x96+J\xe3\xf4\x00I\x96<\xf5\x815H\xef?\x04\xc6\xc8\x10\xa4\xb3\
\x85\xe4\x197\xd5^\x86j\x04<\xe6\xe9\xc6F\x02,\x18\xd31$\xca|\xa4e\xe1\x18b\
\xa3um\x16M\x8d,\x1c\x92\xa6\xb9\xee\xf4\x0f\xed\x0fE\x96\xf6`\xa9\\\xb9\'\
\xb3X]O\xea\xd5\x16{\xc6$Y\x99\xa2\x1cx\x19\xcd\xe5\xa0&N\xc8\x1a\x96R7"0\
\xeaW\xee\xcd\x8a\xc9n\x91\x88:\x03n\xc8\xe8{\x9aMsA\x82:\x9aL%\xcbPRW\xecZ\
\xac\xcc\x160\xb8\x0beQ\xd6\xa5Q\xb4\xe4"F6\xf8\xb5\xa5\xfd\xca\xf2\xbb\xb1`\
\xb1\x17\xa32\xf5\xcd\x9c\xbf\xc0K~5\x89\xb0\x9c0v\x97T\x15)\xb0\xba\x0b\x96\
\xb3\xf0\xbe\xee\x1ab\xad{\xec\xf2\xdbif^G\x9et\xfa\xe1#\xc2\xe3\xbcs\x82\
\xbe\x96\xc6\xde\xad\x0cc\\\x11\xe6\xd9\xfb\xd5!\xa7\xc9Sy\xcb\x10\xa04\xdd\
\xadM\xe9\xfeZT\xb4\x17\xaa\x14]\x11\x88!MJ\xee\xa6d"\\\xa4iub\xff\xe4f\x0bX\
s7\x06-\x86\xb7\x02\xc5\xc5\xe4\xe6W\xf5\xa1P\xc46r\xd5\x1e:z\xb6O\xe5d\x80\
\xe0\x8aW\xd5\x03\xa5E\x13\x98\xcb\x84\x96}\x8b$g\x94\xf5\xec\xedr\xe21Gj1\
\xca\x0c\xb5\x9b\x84\xdabjlU\x97\xfb\xf1f\xbdl\xea\xad\xf0\xcd\x8e\xd2\xbeZV\
|\x90U\xb0J&"\xd9\xeeu\x18\xdc+t^\x98\xa5\xd2C\x05\xa7\x01\xba\xc3\xceD\xc3z\
f\\A\x9a\x9a#\x14Pc\xd0\x08\xc1f\xc7}\xb0\x9cqr\xdfV\xba\xa7\xb9\xf1\\-\xa2\
\x0e\xc5>>%))-\x8c.$\xbag+\x82\xc2\xc2\x15\xdd\x8b\xcdBE\x11\xc3\to:\xbdgy5\
\xe8>\xb0\xd6\x8e\xb4I\xeev\x97+{\xc1\xda\xc7\xa5`\x0e\xe4.W\xc1&\xf0\xe4Z\
\x94\xf6I\x8f\xae\x1a\xf6I1\x1f\xf6\x1f9@\x12\xf2\xd4\xeb2\xf8\xd0\xf2\xc2\
\xad oI\xef\x0c\x1fHvx\xa2\xb7\xc0\x18\xc2,\x81\xfd(\xc0\x88\x9e\x02\xd6>\
\xc3WH{%b\x0e\rl\xcc\x000W\xf9\xdao\xcb\x0b\xd4n$AEa}Z\x90^\\\x89\x12n\xc1\
\xa3\xdb\xe2\x81\xc1\xe4\xc5\xb5\xa9\x02\x88p\x85\xebN\xec\xfd\x8e\xfc\xa1\
\xf2x\x01*\x07\t\xb2(\x19H\x86\xbb\xf4\x97\x81\x92\xc4\xdc\x12l\x9e\xd6\t\
\xa9\nNS\x16\x86C\xca\x17\xa3\xc2\xfcK\x1b\x92oC\xc6\xf1\x16$\xb5\xaco\xbd\
\xb0\x05[hI\xd5T\xf2\xceI\x8f\x9c/\xa5\x90\xc4\x86\x84\xa4\'s\xc0D;Z\xb46a\
\xb5!\xd2\xcf\xb0\x90\xea\xfbg\xf7\x7f\xa5\xef~H \xe7\x8b\x08\xccX\x897\x18[\
\x1cA\xddE\xc2@c\x07\xe5\rH\xf4\xcc\xf9\x95s\x98e\xc0,\xeatK\x1d\x8e\x92\xb1\
\x93H-EH)\xd9\xd0\x93\xb6\x8a\x9fe\xbd\xacQg\x94P>\xc4\x17\xa1f\x07\xc0\xd9@\
Q\t\xbd\x82\xb4Qa\x8er\'1z\xf2y\x06Fj\x1f\xc8r\xae\x8d\xf5\x82t\x0fF\xf2\x04\
\x91\xfa\xedMT\xae\x0e<}v\xc0\xe4\x83\xd2@\x1a\x93\xa9\xefeJ\x03\xfbs\xfcJ\
\xad\xb8\xca\x98\x97O\xf7%\xc6F\xe2\x87y0h\x03\x80DPO\xbe~\xef\xf6\x86\xe8\
\xc6\xb2M8\xb1n\xd4}E\\\xbf\xd9\x17O5t*?\xfb\xff\xaf\x92\x98\xb9\x10\xf0=-DF\
\xc2\x9cq^\xdc\x9d\xde~\xe0\xcb[\x12\x1a\xaaSCd\x8b=\x1d\xf4\xce~`\xfd3\xb9\
\xec\x0c\xe4\xe9\x08 \xfa\x1e],d\x1e\xc9\x9d:p\xabq\x9c\xaak1\xc69\x19\xaa\
\xb0\x98Gs\xb9\xd1o\xd6\x16\'\xde\xbb\x1e>\x9a4\xf6\xa3\xc9\xe0r\x96b\x87(\
\xbf\xfa\xbf5\x1d\x06\xfdzi\x97q\xfe]\xd6\xe9\xfe/\xa1\x82u\xaef\xccX\x1f\
\xb9\x88z\xd8!\x85\xf5\xf8\x94\xbb\xbf9\x8bk\xaaB\\Iv\xbe\x8a\xc3\x0cR4\xd7\
\xa9$\x98\xf2\xe2\xea\xf6\xa18\xaa8\xf4\x9c\x04U\xea\x87\xb1\xf8\x9a\xf2\x94\
\x07\x9e:\xbdhOXO5\xf9\xba\xde\xbc\xfe;\xa6\xdb\xdbXI\'X@\x9a\x0cA\xfd\xd5|&\
%T\xddI\xfd\xeb\xf2\x99\xff\x0f\xff?\xaa\xf7\x91\xcfDu\x7f\x8f\xe9_\x90\xbf\
\\1\xbd\\\xae\x8b\x9b7\xb6\xd5E\xbeyW[]\xcb\x97[*\xbf\xbb\xacr\xec\xb4z{S\
\x99p\xfe\x00\x0c=\xd1\x7f\xbd\xa8:\x04\x00\x00\x00\x00IEND\xaeB`\x82\x15#\
\xb7\xf1' )

def get44Bitmap():
    return BitmapFromImage(get44Image())

def get44Image():
    stream = cStringIO.StringIO(get44Data())
    return ImageFromStream(stream)

index.append('44')
catalog['44'] = ImageClass()
catalog['44'].getData = get44Data
catalog['44'].getImage = get44Image
catalog['44'].getBitmap = get44Bitmap


#----------------------------------------------------------------------
def get37Data():
    return zlib.decompress(
'x\xda\x01\xb8\x02G\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02pIDATx\x9c\xed\\\xd1\x92\xc3 \x08\x94N\xff\xff\x97\
\xbd\x07\xafS\x9b(AdM\xb1\xec\xdcC/\x93BVT\xe8\xca\x84r\xce)%"J[\xa0\xd0y\
\xa6\x94\x88\xa8\xfc\xb3\x01\n\x17J/~\xdb\x80\x88\x1ew?\x03\x04\xcf\xf7\xc7\
\xb2\xb4J\xdc\xeae\xe60\x92\xadX\x1dv\x0e\x87\x1bI\x7f\x06\xe6\xec1J\x05{\
\xae\xab`\xe5\x07\xd3\xac\x10{\xc9\xb4\xcd9V\xc5\xbd-1\x0b\x9b\x13\xacj\xc7V\
\xc4\x8cljY\x9d]\xce\x13\xb3\xb3\xd9gE\xd45:z]\x02S\x9b-V\x87\xe4\xeb0\x17\
\x8f\xd7\xec\x97\x83\xa7\x18\x05S\x9b\xe35\xbbd>\x8c\xce\x19\x80MAu[C2f\xa3\
\xb1\x02\xd8<\xb1\xbaL\x17\xbc\x03\xdd"\xb4\xb6\xf9\xc9\n\x91\x82\xee@\xc5J\
\x9e.z\x83\xc7\x0f*?L:\x9b\x1dh\xb3\xf0\xd9\x99\x84\xd2(1mR\x99\xa8\x98j\x97\
\xf2(\xc9\x89M\xe4\xc9\x8a\x95b\xa8\xca\r\xa3\x13OBl.\xf5\x7f\xc6J1T\xba\xb5\
\xa4[cb\x9cf\xa0\xc5P\xdd\x0eA\x1d\xa8\x06\x1f\x10d\xe6\x80\xfd\xc2G\xd4Vb\
\xc0X!j+1\x90\xba\x85\xba\x0e\n\xdd\xa2\t\xb0n1Z\x07\xb9\xd1-\xe4\xc9}\x85n\
\xc1`4\xb7J\x92;\\\xb7@`mr\x1fg\xa5\xce\xad\xeaMo<\\\xbf\xa3[0\xf0\xaa[L:\
\xf8F\xddb\x17\xa8X\x99j\x0c\x08\x9b\xabt\x8b\xb56\x97\xe8\x16\xcbm\xce\xad+\
Dn\xb5\xd7-\xd4\x0fa\x0b{\xddb\x0b\x04+?\x08V~\x10]$=\xf7?\xa7\xc6\xdcd\xf3\
\xd7\xbaH\x86\xdc\xcf=\x84\xb9\xcd\xd8\x03\x0b\x10\'\x1d\xa1\xc6H\x10j\x8c\
\xc4\x81N\xf4\xf3\xaa\xc6 \xf2u\x1fK\xd4\x18\xc4\xe9\t\x0b\xbc\x1a\x838=\xb9\
\x02X\x8dA\x9c\x9e\x08\x10j\x0c\xf3\x10M NOd\x88\xce\x84!\xf8\xeeL`\x808=9\
\xa3\x15p\xe75{\'\xb9\x83u\x0bD\xd7g\xf3\xb6\xcf\xaf\xe0u\x0bD\xd7g\xf3\x86\
\xea\xca\x12\xdd\x02\xd1\xf5\xc9b\x95n\x81\xe8\xfa\xecc\xa1na\xdb\xf5\xc9Nl\
\xcf{`\x7fb;\xd7-:\x13\xdb\xbfn\xd1\x9a\xd8\xa1[H\x1c\xac\xe9"!z\xff\xd5W^p\
\xb8[\x1cf\xa3Y\x1d\xf8\r]$\x99{M@t\x910.\xa3\x8bd\x81\xcd\xe8"\xf1\x83`\xe5\
\x07\xcf\xeb[\xbe\x13l\xf5\xe80V\x87\xbd\xa4\xb5\xb5\xf8\x8c\xd5U\xbev\x18+\
\x01\x1e9\xe7m^H\x97R\xfa\x7f{\xdb\x96o\xda\xfb\x03\xbagZ\xcc\x96N%\xed\x00\
\x00\x00\x00IEND\xaeB`\x82\x81m>^' )

def get37Bitmap():
    return BitmapFromImage(get37Image())

def get37Image():
    stream = cStringIO.StringIO(get37Data())
    return ImageFromStream(stream)

index.append('37')
catalog['37'] = ImageClass()
catalog['37'].getData = get37Data
catalog['37'].getImage = get37Image
catalog['37'].getBitmap = get37Bitmap


#----------------------------------------------------------------------
def get05Data():
    return zlib.decompress(
'x\xda\xeb\x0c\xf0s\xe7\xe5\x92\xe2b``\xe0\xf5\xf4p\t\x02\xd2\xee@\x9c\xc0\
\xc1\x04$\x0fT\xff8\x06\xa4\x98\x8b\x9d<C888n?\xf4\x7f\xc0\xc0\xc0x\xd9\xd3\
\xc51\xa4b\xce\xdb9\x07\xfb\x0e+\xf0\xb8\xbc]\xf5\xff\xff\xe9{\xcc\xb9.\xccj\
S\x0f\xcd\xe0{\xbd|\xef\x1b\xb9M\x95\x92I\x1d-\x81\xc6\xc2\x82\xa1Su5\xac\
\xfc\x05\x03\xaf~:\xcd&">u\xfb}\xb3\x15\xaf\x92\xbf\xda:T\xcc\xfb_Pu\xd0"\
\xf9\xcf\x99Uk%\xe7\x84.9\xe9\xb5\xaa\xc6b\xea\x93\x9c\xa3\x96\xf7\xa2\xfed9\
JO\xd9\x11\xd6.\x94^e\xab=!(\xe1G\xafh\x88\xa6\xd7\x99\x95o\\=K\xcf\xd5^\x11\
\xe7\x14|\xdd\xeb\xf0\xe5\xc0\xe1\xee\xaf\xcfVw\xfe\xbf\xba{\x8a\xd6\x16\xbe\
\xbf\xed\xa5\t)\x17\x9d\x8f\xb1\x9e~5;\x91\xa7\xfa`\xdb\xe7\xab\xb2\xfbN*\
\xea\xad\xee\x14>\xfdc\xd9\xe3U\xae?\x8e0-\xda\xe4\xe4\xa3\x13\xa7\xf0\xe0\
\xa9\xea\xbeM\xdb\x99~\x88\x16\x9f\xa8\t\xcdn\xa9a\t\t\xbb\xd0\x1e\xa5\'\xfa\
5\xf6\xf3L\xd1/\x0b\xd9\xeaV\x99*\x1b|[\xd8t`\xfd\xcd\xf0\r\xcf_\x99\xad\xad\
\xf0\xd0\x96\xbb\xd4\xd5\xbe\xe5\x91"\t\xcc\xc6\xfb\xab\xb6wN\xbcs\xea\xa6\
\xbft\x86i\xed\xe9\xd5\xfb\xe7\x9b\x9d\xca\xaa\xfa~\xba\xc0>\xb7\xe3\xaa\x7f\
\xc9\xfe3\xa9\xae\xdf\xb9od]\xf8[4\xf9a]\xd43\xa9\x17\xef\x97\xbbF\xc5\x96\
\xed\xbfs\xfc\xa6\xff\xe9\xfb\x7f/\xdd\xf6\xe7\xde\x1cu\xeb\xef\xa5\xd7Sg\
\xb7\xde\xd4\xe8\xb5\xf6\xba{:/H\xb7\xe6@\xd8\x85w\xe2\x9b\xaf\xfb3\xd7\x7f?\
\xbd\xc9\xf4\xf7\x17\xb7^e\xa5\xe5\xe9\xd6\xaf\xf6:\x99d\xfd\xc8}\xd1xU\xc9\
\xcb3"\xfb\xc1\xd5D\xc69a\xac\xf65i\xab\x9b\x9f\x89\xb0<\xb9\xc5\xd4\xbb\xbf\
\xe0\xe1\x99WY|K\xcefE\x04Zn\xde\xf5(1\xed\xb6\x8c\x87\xfa\xf1\x97\xb9\xd1\
\xf3\xb6|g\xbf1w\xee\x11\xfd\x86\x97S\x80\xb1\xcd\xe0\xe9\xea\xe7\xb2\xce)\
\xa1\t\x00\x82\x88\x07\x9a' )

def get05Bitmap():
    return BitmapFromImage(get05Image())

def get05Image():
    stream = cStringIO.StringIO(get05Data())
    return ImageFromStream(stream)

index.append('05')
catalog['05'] = ImageClass()
catalog['05'].getData = get05Data
catalog['05'].getImage = get05Image
catalog['05'].getBitmap = get05Bitmap


#----------------------------------------------------------------------
def get09Data():
    return zlib.decompress(
'x\xda\x01>\x02\xc1\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x01\xf6IDATx\x9c\xed\x9c\xcb\x92\x85 \x0cD\x93[\xfe\
\xff/3\x0bj\x1cT\x1e\xde!\tv\xcc\xd9\xe9Bm\x12\x02\x95.\xe1\x94\x12\x1113\
\xb9 \xcb\xd9\x88\x88\x99\xf3\x85\x03\xb2\x16\xa6_}n`\xe6\xcf\xeaoPa;\\Ug\
\x17`$}\xc6\xaa\xa6*\xa5\xbf\xf8\x00\x06\x8a\xce\x19\xb8k\xc8\xa9\x88)\x89\
\xea\xb1\x02\x97D\x15U{\xc1`\xae\x17\x0f\x04F\xd5BP\x98\xe1\x18m\xe7\x1be\
\xe2\x89Kb\xb6Il\x93\xca^\x8e\x8eI\xc4\x8e\xaa4\xe6\xd2\xf5\x81\xfa\xc2.\x19\
(\xfb\xd6\xd6\xa3\x94S\xf1\x18\xab\xeb\x9b0\xeb{\xb7ZL\xd2\x8f\xb9f\xb8\xd4\
\xaa\xc5\x9d4V\x9b`\xed\xbd\xc5$w\xe2`\x17\xab}a\x99\xa7\xff\xd1v\xd5\xc2|aQ\
\xa2P\xa5\xb1\xb0\xb4\x02\xa2\\Z\xf5\xf7\x16+V\x0b\x93\x1dS)\xc3z\x1f\xa8:\
\xa8\xf9QVkz{o!\xfe\x05\x86\xdb\x94K\x06\xda\x0e\xaa\x12\x8dn\x0c8\xef\xe9\
\x9c\xe1\x13\xaap\x08U8\x84*\x1cB\x15\x0e\xa1\n\x87P5\x89a{\xc7J\x95`C\xee\
\x06opz4X\xe1\xf4(\xab\xea8=\x9aD\r\xfc\x96\xa1\xd3\xa3\xc6{\x9c\x1e\x11\x9e\
\xe5\xf4\x08\xf2\x14\xa7\xc7\x0b\xca\xaa\xc2\xe9\x11\xc4\xbd\xd3\xa3\xcaJ\
\xa7G\x95\x95N\x8f\x0bB\x15\x0e\xa1\n\x87P\x85C\xa8\xc2!T\xe1\x10\xaa\x9eI\
\xad\xa5\x03\xae\xaa\xd1\xbeG\xf6D\xda\xed{XO\xa4\xdb\xbe\x0fO\xe4\x7f\x84\'\
\xf2\x05\xdd\xd6\x15r\rl\xb7\xae\xc0=\x91F\xeb\n\xdf\x13\xa9\xb5\xae|z"\xb5\
\x7f\xe5\xa4H\xa9\x17\x8dII\xa7\'\xdb\xcd+=F\xab\x05\xb2\'\x92\xcf\x0b0\x9dW\
\xe5\xbb\x87w\xe6_\xb1 \x03\xcd=\x11\xcdjQ\x92+\x87\xac\xa4r.-\xab\x16\xe2\
\x7f\x08\xb5\xc1\xac\x8148Z\x04V\x15\xf5\xce\xe1\x80UUJ\xba\x1c\x1f`U-d)\x8f\
\x16\xa9\x01\x1b\xab.\x98\xb1r[\x03\xbb|RJn\x0e\xa4\xa3\xfd\xf46\x97\'\xed\
\xfd\x00\\\xae\xbd\xc2\xba4\x04\xca\x00\x00\x00\x00IEND\xaeB`\x82^\xb5\x02\
\xc4' )

def get09Bitmap():
    return BitmapFromImage(get09Image())

def get09Image():
    stream = cStringIO.StringIO(get09Data())
    return ImageFromStream(stream)

index.append('09')
catalog['09'] = ImageClass()
catalog['09'].getData = get09Data
catalog['09'].getImage = get09Image
catalog['09'].getBitmap = get09Bitmap


#----------------------------------------------------------------------
def get13Data():
    return zlib.decompress(
"x\xda\xeb\x0c\xf0s\xe7\xe5\x92\xe2b``\xe0\xf5\xf4p\t\x02\xd2\xee@\x9c\xc0\
\xc1\x04$\x0fT\xff8\x06\xa4\x98\x8b\x9d<C888n?\xf4\x7f\xc0\xc0\xc0\xf8\xc5\
\xd3\xc51\xa4b\xce\xdb9\xde|\x87\x15x\\\xde\xae\xfa\xbe\xdf(v\xc1\x82-\x07Y>\
l9\x19p~]\xa0\xe9\xc3\x8f\xa5*\xd2\xbe\x9a\x9d\x1d\xabN\t\x9d\xb2\xf0\x17\
\x0c\xbc\xfa'\x991Uljo\xbe\xe4\xcaW\x8f_\x99\xd5\xb8\x9aM]uA\xcf\xac\xb9k\
\x9a\xfaj7\xd7>\x15Q\xad:\x95\x9fK\xb4<\x9e\xec~\xd4\x97%\xaabx=T\xf1\xcdM\
\xce\x8d\x93\xc5\x1e>\xb3[_\xa4\x1c\x90\xa0`n\xbd\xed\xc4\xb5\xb77\x7f|\xacz\
~\x85u\xe7\xcf\xa4\xee\xe4\xfe\xaa_\x12\xaf\xca\xca\xb8\xa2\xaf->\x7f\xfb\
\xd0.\xc6kWuME7\xcf/{8A\xf1ZnQ\xec\xd73]\xfff6\x97\xde6\x91c\xff\xf6%\xa6\
\xfe}\xd2]3\xc9\xc2\x05\xec9[\x04#\xcc\x05\r\x1f;\x1c\x94]\x13\xbeB\x8c\xddl\
\x9eHd\xacEyI\xd2\xdd\x18\xeb\xdf\x1f\xa7\xce\xbb\xc1\xf4\xea\x99\xf5\xfao\
\xfa\xdf\xdc\x7fYl\x97\xbd\x1a\x93\xff\xf4\xff\x02\xbb8\x87\xbc\xf7\xc9\xa6\
\xd7\xa3o\xbc7l\xb9\x9d\xc8\x96\xf4\xfb\x9f\xd2\xd5k\xa2\x96\x93\xd6H\xdde\
\x13\xedo\xearw<\xbax\xc1\xa3\xc0\x80\x8f\x1a+*DBl\xb8\xb4\xe4X\t\n\x0b\xda\
\x87\xeavN\x9cs\xea\xc4r\xd7\x80\xd8\xd0\xbfI\xcf/_\n\xdbo\xf29\xb36\xe4\xc6\
\x9b\xe49\xb7\xe3C\xf7\xfb\x98\x1c\xba<\x85s{\x9a\x9d\xeeg\xb9\x8c\xe7\x97\
\xfd\x02\xb7\xb2\xa7\x94\xec\xb0\xc9s\xb3\xd3\xad\xff\xea\xad;\xbflN\xd7\xa6\
_G\xefO\x91\x0f\xd9\xff\xe4T\xc4n\xbbi\x95\xdb7\x98z\x97\xe6~\xf5\xae\xcc\
\xfb\x93x\xf6\x95\xf8\xf7X\x95\x1bV\xdf\xe5\xb6o^,Y(\xce\xe9\xf8\xb5{\xb9\
\xa6\xc6\xdc]K\xbfl[g\xf0\xfc\xea\xdd\x90\xd9[\x9e\x84\x1c\xb3RY~\x8a\xe9Hc\
\xf9\xe5\xa6\xd7\xa7nD\xcd\xb3\xcfc\xf39\xbbvR\xcd\x1a\x1e\xdb \xaf\xd31\x1e\
\xeaO\xbfmS\xcd\xbfU\xcd\xd8\xf3\xe5\xcc\xee\xce\x92\xe6\xe3\xc0\xe4\xc0\xe0\
\xe9\xea\xe7\xb2\xce)\xa1\t\x00\x87\xc2\r'" )

def get13Bitmap():
    return BitmapFromImage(get13Image())

def get13Image():
    stream = cStringIO.StringIO(get13Data())
    return ImageFromStream(stream)

index.append('13')
catalog['13'] = ImageClass()
catalog['13'].getData = get13Data
catalog['13'].getImage = get13Image
catalog['13'].getBitmap = get13Bitmap


#----------------------------------------------------------------------
def get17Data():
    return zlib.decompress(
'x\xda\x01v\x02\x89\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02.IDATx\x9c\xed\\\xcbr\xc3 \x0c\x942\xf9\xff_\xa6\
\x07\x92\xd66/\x19-`Q\xed\xe4\x90\xce8\x1b\x965\x82H\x959\x84@D\xccL[ \xcay\
\x13\x113\xc7?6@\xd4\xc2\xf4\xd5\xb7\r\x98\xf9\xb5z\x0cC\xf0\xfe{\x9b]Z6m\
\xdc\xde\xab\x08\x9b\xe6\\\xf0O\xbc:\xae.\xb3\xbeU\xbd2\xbb5\x1f\xbc\xba8#\
\x97\xc4\x8ct\x15\xc1\xa6^WQ<\xcaU\x10\xdbA\x15\xf3m\xba\xe3\xf5za86\x85W\
\xe9\x17k\x86\x02eKTE\xc7\x9a\x8c\xa5\x0b\xfa\x86\x82e;\xa9J\xd7\xa8\xd9\xc8\
\xdeufoN\xe1-B,[\xe7\x99]rW\xdc\xda\x15\x80l_\xe4T\xd5Y$3\'\x9f],\xdb\x17\
\xb9hA:aw\x07\x81e#\xa2\xab*\xec\xfe\xb3\x0e\xe7]\xf8\x82\x8a\xb0\xd2\x14\
\xf6\x85M,\x9bj\x17\xc6\xee\x04P6\xdd9\xf0\xf8\xc5\xfa\xcd\r\xc7\xa6\xde\x85\
\xe35\xa8\xfd\x1a\xc4v\xf6\xaao\xb6\xb0G\x10\x04[r\x07b\xe7~\x11r\xeb\xca\
\xb8$\xda5\x1b\xe3\xaa\xec\xc0U\xd9\x81\xab\xb2\x03We\x07\xae\xca\x0e\\\x95\
\x12\x13\x13!\xb3TaK\'-LQ5=u5^\x15\xb6t"\xc3`U\xe8b\x87\x10\x1e\x03\xef\xa2n\
\xc8H\xbb\x86\xa9\x1aS\xec\x10b\x98\xaa1\xc5\x0e!F\xde\x81\x03\x8a\x1dBx\xb4\
\xe8\x00\xba\xd8!\xc4x\xafV\x14\xd1\xa7\xdc\x81\xd8\xd2\x89\x00\xb3\xd6\xd5\
\xdc\xf4\xfd\xc4h11}\xef1\xd0\x0e\\\x95\x1d\xb8*;pUv\xe0\xaa\xec\xc0U\xd9\
\x81\xabz&r\x89*\xe3\xaa\nE\t\x84*lZ\xaf\xef\xff\xab\xcf\x9f2\xdb\xfdR-J\xe8\
Ty\xf7\xcbL\xb6^U\xcb\xbb_\xaa\t9\xcb1\xb0\x9c\x90\xebR\x85-\xe1h\xd8\n\t9\
\xfb\xdd/\xb9\x84\xdc}U\x16\xba_\x92~a\xe1P:\x9a-\xb0l\x97\x8f\x00\xd6\xd5r\
\xb4\xb6\x81^UO\xe8~\t\xe1\xf3J\xe0\xdd/\xf5\xa1,\xec~I\x1cS\xaf\xabGv\xbft\
\xc5\xc0\xecPP\x90\xb3\x95\xc3\xa0\xcd\x18\xd8R\x8e\xf0j\t\x8e\xc2\x86\xfc\
\x16~\x1elz\xd5:=\xbaW\xcfA+Z\xec\xe9\xd5+\x84\xb0\xcd\x03\xe9\xe8\xf7\xe9m[\
>i\xef\x07no\xe4\xc1\x9a\x8f\xd3f\x00\x00\x00\x00IEND\xaeB`\x82.\xba(`' )

def get17Bitmap():
    return BitmapFromImage(get17Image())

def get17Image():
    stream = cStringIO.StringIO(get17Data())
    return ImageFromStream(stream)

index.append('17')
catalog['17'] = ImageClass()
catalog['17'].getData = get17Data
catalog['17'].getImage = get17Image
catalog['17'].getBitmap = get17Bitmap


#----------------------------------------------------------------------
def get21Data():
    return zlib.decompress(
'x\xda\xeb\x0c\xf0s\xe7\xe5\x92\xe2b``\xe0\xf5\xf4p\t\x02\xd2\xee@\x9c\xc0\
\xc1\x04$\x0fT\xff8\x06\xa4\x98\x8b\x9d<C888n?\xf4\x7f\xc0\xc0\xc0\xf8\xcb\
\xd3\xc51\xa4b\xce\xdb\x98\x8b}\x87\x15x\x94/\xff\xfb?}g\xfb;-+\x0e]O\x8dR\
\xb1l\xfd\xf2Y2>\n\x1b"t\x9f\xce\t\xf6r\x99\x12\x930\xf9\xb3\x9f\xa6\xe0\xc5\
o\xed\xcc9Q\x1a\x7f_\x173+U\xad\x95;,\xb2G\xfa\xbf\xf6w\x894\xa9\xd51;5\xa4\
\x8f\xc7\xbc\x9dd\x10\xbce\xf1\xd6\xf5\x07T\x97\xce\xbf\x19\x1e\x7f\xe0N\xda\
\x19\xae;v\xe1\x06\xce\xdbf\x05\x97\xc7\xe5>\xccm\x8d,\xd0\n\x99\xda\xb8\xb6\
E\xb2\xd0+\xf4\xaa\xe2\xd7Co,\xa2Wu\xd8\xcd\x7f\xfd\xb0\xb4\xd9\xe0\xb9\xcd\
\xaaU\xda,i\xa9\xf2\xfb7\xcf\xf7\x9b\x97\xa0\xe4cy\xfc\xfd\x9b\xd5\xaf~$\xc4\
\xa4\xc5\x17\xce\xd8\xa8\xb0\xbe\x80\xefX\xea\xbb7I\x89F7\xaf\xcdq\x0f5\xee[\
 \xaa\x11\x12k\xaf\xb7\xe3\xe4\xe55\xfe\xc1~/5m\x1e\xf3lx\x1crg\xc6\xa9\ta\
\xa1G:6\x07\xa8\xceX\xf5\x96{[\xeb\xc5\xa6\xc9\xfb\xa3c\x9e\xc4\x86\xbe\xde\
\xbd"\xecA\xcf\xcb\xfd\xb2v\xbf\xc5\xecv\xcfY\xc8\xc5\x8e\x86\xb2B\x1f~\xb9s\
L\xd2\x8f_<\xce\x96\xa3\xd8o\xa2\x96\xc1\xf2\xe3\xdc\xc7B\xbf\xaa\xfbO\xd3\
\xcb>w\xbf\xb0\xca\xca\xa1\xb4j\n\xe3\xbc\x17_*\x1a=B-l\xbd-\xeeZ\xdb>r\xb4\
\xb9\xfbR\x90\xff\x90\xd87\xbf~\xee\x16-\x19\x14\xb4*}\xd1\xd5\x15\x8c\xe1GM\
\x9eN\xb4\x15\xdc\xa7\xc9\xff\xba\xb3d\xf6\xa7\x87\x9d\x05\x0f\xaf\x02\xfd\
\xdb\xf2\xd5e\x17\xaf\xe6\x13\xa9\x13\xe6K\x0e\xd8\n.Sl}\xdf\xb9E*\xc8\xcev\
\xe2\xb5\xcf\x87\x963\x9e\x91\xff%XPW\x1b\xbf{\xfd\xbc\x86\xcd\xc6\x0c7\x85\
\x1f\xce\xcf\xe6\xf3_"ld3Q\xda\xe2xvB\xb1\xc0\xb6\x80\xfdL\x0c\x9b\xd9\xe6\
\x9d\x0c{\x9e%\xea\x95\xf8m\x7f\xeb\xf4\xc5[\xf9\x12\x8b\x9f~\xc8\xfb\xd8\
\x9a5\xfb\xe0\xb3U\xd1\x061OV\x1d\xd2~\xfe\xe6YkIf}\xf5\xec\xd3\xe6o\xff2>\
\x0f\xfc\xb1\xff\xb2\xe8\xdd\xc5\xc0D\xc1\xe0\xe9\xea\xe7\xb2\xce)\xa1\t\x00\
\x86\xb5\x03\xee' )

def get21Bitmap():
    return BitmapFromImage(get21Image())

def get21Image():
    stream = cStringIO.StringIO(get21Data())
    return ImageFromStream(stream)

index.append('21')
catalog['21'] = ImageClass()
catalog['21'].getData = get21Data
catalog['21'].getImage = get21Image
catalog['21'].getBitmap = get21Bitmap


#----------------------------------------------------------------------
def get25Data():
    return zlib.decompress(
'x\xda\x01g\x02\x98\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02\x1fIDATx\x9c\xed\x9cQ\x8f\x84 \x0c\x84\xe9f\xff\
\xff_\xe6\x1e\xc8n\xf4\xa4]\x84):\xd8\xef\xed\x92K\xebX,\x96\xc9*9\xe7\x94\
\x92\x88\xa4%(r\xde)%\x11)\x7f,@\xd1"\xe9\xa3o\x19D\xe4u\xf55\xb8\xf0\xde\
\xfdU}\xba\x08+\xf9\x84Z\x15\xbe\xc5\xa1m\x8c{U\xdb\xc5V$\x11.\xbf\xb4\xea\n\
TT1\x17*\x01j\xe5\xf1\xec\r\xc7\x1cSU\xd2c\x85!b\xd6T5.\xbfmb\x940P\xcc\xdeZ\
\x1dS\x8e\x0b\xc3\xc5\xecR\xa5%\x1b\x11\x06\x8d\xf9\x9c\xce\x9e\xb3\xf5P\xd9\
7\xaf\xaf\\\xe8\x98\'kuU\x1f?\x99W\xef\x81U<\xf6\xe5\x96\x98\'\xf3\x1eT\xfd\
\xdc.\xec\x04}\xb2\xd11\xf7\xaa<\xb6\xa0+\xd8\xa8j\xdf.\xb4\x9b7\xb2>\xa11{;\
\xfb1\xd9\xf8#\x87\x8b9\xb0_mS\xa2\xba\x08(\xe6FU\xc7\xad*\xff\x80m\x8c\x88\
\x98\xfbZu\xdc\xaa\xabz\xbd\xc9a\x05z\xdc\xfe\xc2\xc4\xa6\xaa\xbc1\xc1\xf1\
\x98\xc4t\xa6\xbc\xddN\xdf\x06\xfdUyLb\xbfpV\xe51\x895\xf0\x9c\xf9\n\x85\xc7\
$\xd6\x86\x9b*\x87\xa9\xa9\x1d7U\x0eSS;\x9e+\xd0c\x12k#\xbaE\x07\x1e\x93X\
\x03\xfe\xb5\xf2\x98\xc4~1e\x05zLb&\xb3\x9e+\xbfQ\xa0\xc6D\xa7\xa7]R8=U\x06T\
\x85\xd339f8=<\x9cW\x15N\x0f,&\xc0\xe91`uz\x06\x13\xdc\xd1\xe9Y\x85.U\xe1\
\xf4\\\x12sy\xa7\xa7\xfb"\xee\xee\xf4t_\x04\x16\xbc\xd3\xb3\x04\xa1\x8a\x87P\
\xc5C\xa8\xe2!T\xf1\x10\xaax\x08U\xf7\xa4vPC\xaeJ9\x94g\xfe\xf5\x8b~(O\xeb\
\x89\x98\x87\xf2\xe1\x89h\xe9\x87/\x02\x1e\x93\xd6\x131\x0f\xa4\x98{\xa0~ E\
\xee\x89(\x07R\xfc\x9eH\xed@*<\x91\x96\x04\xf3=\x11\x11\x87w\x8b[\x12\x9e\
\x88\x9d,<\x11XL\xe5\xa7\xcd\xe1\x89\x18\x17\x81\xe5\xd1\x9e\x88\xfe\xcbzfU:\
\xb4\xaa\xfe\x15j\xbf\x17\xd7\xbe\x1bC\x84\xf2~H[+\x13\xdaZ\x99}r\xcdZ\xbdr\
\xce\xcb|\x90.}\xbf\xde\xb6\xe4\x97\xf6\xfe\x00\xc4\x8b\xff\xc6\x81\xb9\x08b\
\x00\x00\x00\x00IEND\xaeB`\x82\xc3Y\x1e\x85' )

def get25Bitmap():
    return BitmapFromImage(get25Image())

def get25Image():
    stream = cStringIO.StringIO(get25Data())
    return ImageFromStream(stream)

index.append('25')
catalog['25'] = ImageClass()
catalog['25'].getData = get25Data
catalog['25'].getImage = get25Image
catalog['25'].getBitmap = get25Bitmap


#----------------------------------------------------------------------
def get29Data():
    return zlib.decompress(
'x\xda\x01\xae\x02Q\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02fIDATx\x9c\xed\\\xd9n\xc30\x0c\x93\x8b\xfe\xff/{\
\x0f\xee\x80\\\xf2%\xd2\x89\x1c\x13{\xd9V\xd0\xa1\x0f\x1da\x93\x10c\x14\x91\
\x10\x82L\x81$\xe7+"!\x84\xf4\xcb\x04HZ\x82\xfc\xeb\x9b\x06!\x84\xcf\xdd\xd7\
@\xc1\xf7\xf8\x87\xc3\x01\xf3\xb9\x8c\xfb\xb5:\xc7\x0c\x9fQ\xe4\xb4V\xb2Y\
\x1f\x9f\x92\xe4\xb8V\xb3`NU\xfb\x1d\x18\xa3\x84\xb0\xdbx/\x8d\x16\x8c\xb3g\
\xe6\xbc\xda\x811\xfe~*\x87\xc7\nCp\x1a\xce\xd5v`\x940\x10g\xaf*Ff\xc3q^\xa9\
J\x01#\xc3\xa8\xfd\xcb"\x0c\xca\xb9Wu>K>c`{\xcd^\x9c\xbc\x8e\x89\x80r\xb6\
\xd7\xec5\xfb\xa1u\xcf\x108\x95s\xa5\xa1f\xceZ\xd7\x8a\xc0yRUL\x17\xf9\x01\
\xfa\xce!\x9aS\xaf-\xdc\x16\xec\xb2SU\x9f.\xb4\xc9\xb3\x04L(go\x16f\xe4\x00\
\x1c\xa7\xa1b\xda\x0e\x89Jk \xce\x8d\xaa\x8e\xa9J\x1f\xc0fj\x04\xa7^[T\xf22\
\x8a\x0f3\xe7i\x072\xa6?a`PU\xfa+8\x18\x9d\x98\x8e!\xf7-\x86\xa7A\xbe\xaa;\
\xee1\x92U1:\xb1\n\xccy\xe7\x8c\xa9*\xbf \xcc\xe5\xa2\xa9btb\xd5\xa0\xa9btb\
\xd5`\xee@F\'V\x87\x15-:\xc0\xe8\xc4*\xc0_\xab;\xee\xc6\r\xd9\x81\x8cN,\x0b\
\xb3\xaa\xca\xe8\xdc\xd4\nP<\x91z4U\xe2M\x92\x96\'r\xc6{<\x91\x8e\xe1m\x17\
\x01\xe7\\Y8\x81Q\x89\xa39\x1f\xe0\x89\xa0\xc6\xdd\x80\xb0\x03[\xf3,a\x16\
\x1aU\xddu\xf7\xcf\xea\xf4\x18\x07x\xa2\xd33\x0b\xbaT-\xa7\xe7\x16\xce\xe9\
\x9d\x9e\xee\x8b\xc0\xf6\x17x\xa7\xa7\x03\x8c\xfe\x02\xef\xf40\xb0\xdc\x03\
\x08\x96{\xe0\x07\xcb=h\xc2r\x0f\xe0X\xee\x81\x1f,\xf7\xa0\x0f\xcb=@a\xd4\
\xb9\x1a\xfbE\xa2\x81\xd1b\xe0\x17\x89F9=\x0cN\xbd\x15\x18\xe8\xf4`9\xb3\xad\
\xc0rz\xb4\xe1\xcd\x17\x01\xe7t\xeb\xf4d\xd3\xa0\xe7\x8aIO\x83\xce\x9d\x1e%\
\r>\xc0\xe91r^\xa5A\x82\'\xf2\x80\xa7_\xae\x9e\xed.\x0e`|\xe8\x07\xc2y\xf8\
\xbc\xf5\\=\x01\xa5\x1c\xe0\xd9\x13\xd1\x9f\x00^\x9eHf\xc8\xf7z"pN\xfd\t\xe0\
Q\x9e\x08\x96\xb3\xb4W=\xc7\xc0m\xb4@\xf6WO\xc5\x9c\xaa\xdak\x8b\xe7@/G|\xae\
U)Z\xb8]\xabl\x9c\xf4\xb9V%|b\x8c\xd3\xbc\x90ND~oo\x9b\xf2M{\x7f&\r8\xce\xc4\
;5_\x00\x00\x00\x00IEND\xaeB`\x82\x92o@H' )

def get29Bitmap():
    return BitmapFromImage(get29Image())

def get29Image():
    stream = cStringIO.StringIO(get29Data())
    return ImageFromStream(stream)

index.append('29')
catalog['29'] = ImageClass()
catalog['29'].getData = get29Data
catalog['29'].getImage = get29Image
catalog['29'].getBitmap = get29Bitmap


#----------------------------------------------------------------------
def get33Data():
    return zlib.decompress(
'x\xda\x01\xa9\x02V\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02aIDATx\x9c\xed\\\xd9r\xc3 \x10[2\xf9\xff_\xa6\x0fNS\
\xdb\xb0x\xd9\xc3F\x14M\x1e\xd2c\xb4\xc8\x18\x10\x1a\xec\x94s&\xa2\x94\x12M\
\x81M\xce\x9b\x88RJ\xdb\x0f\x13`\xd3\x92\xe8W\xdf4H)\xbd\x9enC\x08\xde\xe7_\
\x9c\x06\x18f7\x1e\xfb\xaa\x9c30g\x91\xa2\xafh\xd7?\x98\x92\xe8\xdcW\xb3`\
\xa9\xc2AMUJ\x9f\x8f\x04\x11c\xcf\xccyT\xd5;\x8fo\xe5}\x85yp\x16}\x95\xf3\
\xdfGR\xbe\xfcn\x81\x13\'?\xae\xda\xa4\x11+\x9b\x1fg\xa1\xea4\xa8\xaa=\xc6\
\x15\xb3\x08s\xe5l\xce\x81\x98v\x89\x88\xfa=\xfb\xe5\xc5S\\\x0bW\xce~\xcf.\
\xb9\x1fz\xef\x99\x00Nf\xbd\xe2 \xb9f\xbd}\x15\xc0Y\x9b-\xc8 L7\x14\xbd9\xf9\
\x9d\x08\xaca\xa7\x83*\xf9r\xc1]<\xcb\x9c\xe9\xca\xa9u\xb7e1\xfb2\xe0\xc7i\
\xf0\xec\xfb\x92^+\x9b\x13\xe7N\x95\xe2Rm\xff\xe0\xbbX{p\xf2\x9e]\xc8\x1b\
\xe1?\xcc\x9c5\xcf\xee\xc1\xfb,j\xe3\n\\\x12\xfd\xa7\x1d>>\xcc\xaa\x00r\x0b]\
y\x80\xdc\xa2\xb7|\xf9\xdd\x82\xf0\xdcB^\xde\xdc\x08wN\x95*\xec\xdc\x02\x16\
\xfd\xaaz\x13\xb5\'8\xffOn\xd1\x00jna,0bn\x11\x8a\x1b\x83\x10\x95*E\xc6\xa0\
\x8e\xae\xc6\xcd-\x84\x8e\x01)\xb7\xe8r\x0c\xfe\xb9\x85\x02\x97\x1bg\x85c\
\xf0\xcf-\x14\xc0\xc8-\x1c\x11\xe1Bd\x08S\x15\xe1B\xc4\x08S\x15\xe1B\xc4\x88\
\xbc\x03#\\\x88\x0ck\'RE{l\xe8\x1c\x03@\x1a\xd3\xeb\x18`\xd2\x18\xb9c\x00Kc$\
\x8e\x012\x8d\xd1\x8d\xa5\x95\xc6|\xb1\xd2\x18a\x81\x95\xc6\x04q\xae4\x06\
\x07w\xa51\xf7r\xaeS$\x8d\x92\xe3\x9e"Q7b\xf4S$\xeaF\xf8b\xe84\xe69,Uc\xa2f\
\xa6\xc0U1\x1bg\xe4S$\xfc\xc6\x19\xf6\x14Is\xe3\xbcN\x91p\xe5\xcd\x8dp\xe7\
\x84=E\xd24\x8d\xc8s o\x1a\xc1s\x0b\xc64\xe2\xe7\x165\xd3\xb8r\x0bI\x81;s\
\x8b\xefc}\xfe\xde\xe2)4\xef[\xcc\xdcb\xff\xd8e\xedqY\xe4\xdc\x82\xff+rn\x11\
5\xae\xc6\xc9-\x8e\xc2j\xef\xb7P4\xc2\x17\xbd\x0f\xde\xcc3\x076\xb1T\xe1\xc0\
<\xae\x1e\x04\xbf\x10c\xf6\xd5\xd5\xca\x06\xdbW\xcdy\x12\xb3\xaf\xae\xf0\xca\
9O\xf3B:"\xfa\xbc\xbdm\xca7\xed\xfd\x00S`J\xd8\xf5\x0c\xe8\x97\x00\x00\x00\
\x00IEND\xaeB`\x82*#>!' )

def get33Bitmap():
    return BitmapFromImage(get33Image())

def get33Image():
    stream = cStringIO.StringIO(get33Data())
    return ImageFromStream(stream)

index.append('33')
catalog['33'] = ImageClass()
catalog['33'].getData = get33Data
catalog['33'].getImage = get33Image
catalog['33'].getBitmap = get33Bitmap


#----------------------------------------------------------------------
def get01Data():
    return zlib.decompress(
'x\xda\x01\xfc\x01\x03\xfe\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\
\x00\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\
\x08\xdb\xe1O\xe0\x00\x00\x01\xb4IDATx\x9c\xed\x9c\xc1\x8e\xc3 \x0c\x05\xed\
\xaa\xff\xff\xcb\xf4\x80\x92\xd2\x06\x93\xa8\x12n\xc6xn\xe5\x94\xd1#\x0ekk\
\xd1R\x8a\x88\xa8\xaa\x84\xa0\xea<EDU\xeb\x8f\x00T\x17\x95\xcd/\x0c\xaa\xfa\
\xf8\xf73L\xc1\xb0\x82\xbff\xebdU\x83"\xc7\xb5HV5\xa2Z\x15\xb1q\xad\x90U\x1b\
\x149\xaegg\x8di\xd2\xd2de\xc9\x00%\x0fY}\x9d\x9e\x80J\xf2\xcej\x7f\xfaV\xa3\
\xbbH f\r\xdcv`\xf7\xd8\x8e=\xcb\xc7\xccj\x9d3{\xc0\xd3m\xb7\x06\xd2\xe8\x9d\
\x98\xc6+\x04\x96\xaa\x16p>\xad\x8e\x1f(\xe6\'\xeb\x90U\xab\xc1T\x92\xfe\x0e\
l\xff\xbebb\xbcWd%Y\xa3ZD!\xad8\xa4\x15\x87\xb4\xe2\x90V\x1c\xd2\x8a\x83\xaf\
\x95W\xbf\xc0\xd1\xca\xb1u\xe5e\xe5\xdb\xbar\xb1ro]\xcd\xb7\xfa\xc7X,k\xe0\
\x0f\x8c\x03\x99\x16\xd7L\xab+\x0f=Gl\xa6\xd5\x95\x96\xce\x9c\xb6\xcf\xe4\
\x1d8~\xe8i\x9d\xac\xac\x16\xbfa\x052\xb3\xe5\xe8\x92\x95{\xfb\xdek\x07\xfa\
\xb6\xef\x1d\xdf+\xc7\xf6\xbdo\xb5\xf0j\xdfg\r\xe4\x90V\x1c\xd2\x8aCZqH+\x0e\
i\xc5!\xadn\x88\xd1\xa2"[\xd9\xe3\x08\xac\xd5p\x1c\xc1\xb4:\x1bG0\xad\xceH\
\xab\xfbp\xd6\x8acZ\xc9I+\x0ek%\xa3V\x1c\xd9J\xccV\x1c\xdc\xca\xa0\xf7\xdf\
\x9a\xb7\xa5\xfd(\xed)\xf5\x16cf\x85\xb2\xda\xf3\xe9\x16\xc0f\x11\xb5\x03w\
\xce\xa6\xc9\xa8\xac\xe4\xea\x8c\x8f\x99\x95\x18\xd5b\x83\x96\x95|^\x10\xd0^\
\x1c\xd0\x00\xb4\xba\x00\xd3\xaa\x8d+\xe0\x89\xc9\x00k5\x9c2c\xad\x86\x90\
\xad\xec\xd99\xd9\xca\xe6QJ\ts!\x9d\xec\xb7\xb7\x85\xbci\xef\x05H\xf0}\xc6{\
\x98\xd3r\x00\x00\x00\x00IEND\xaeB`\x82\xd2\x9b\xf6{' )

def get01Bitmap():
    return BitmapFromImage(get01Image())

def get01Image():
    stream = cStringIO.StringIO(get01Data())
    return ImageFromStream(stream)

index.append('01')
catalog['01'] = ImageClass()
catalog['01'].getData = get01Data
catalog['01'].getImage = get01Image
catalog['01'].getBitmap = get01Bitmap


#----------------------------------------------------------------------
def get41Data():
    return zlib.decompress(
'x\xda\x01T\x06\xab\xf9\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x06\x0cIDATx\x9c\xed[W\x92\xdb0\x0c\x052\xb9\xff\x95\
\x91\x0f6t\x82\xb2\xb5.YLF\x91)\x16<>\xa2\x90\xd2"\x11\x01\x00"\xc2WH\x83\
\xf3\x17\x00\x10\xb1\xfd\xf8\x02iX\x10\x06\xbe\xaf\x11D\xfc\xf3j\x1dn\x91\
\xbfN\x19\xb7\xb1\xcf\xa4\xf1;\xb9\xf2PM~>\x93(\xf8\x9f\xb8\xfa|\xf9E\xf59\
\xe2yv#o\x95OUr\x06\x86\xaa\xa9\x1e\xb4I\xfaBDj\r\'\xf8y\xbf\xbb\xc1\xb2\xa2\
s\xacJ\xb5\'\xac\xc0\x9ew!\x1eD\x82-\xa4\xc7V\x87Y\x81\x97\xba#"D$\x17\x98[R\
\x81t4M\xaa\x03\xd1u\x90+5\x1d\xb6\xeb\xa4/\xc5\xf2\xc0%\x96d\x9d\xca\xf6\
\x02\x11%Wi\x83R\x8f\xf9\xe3\xad\xd8\xf6\x08pNX\xc9\x076i\x0b\xa7n\xd9\xcd/D\
\xf5\x11Q\xf7\x86\xe0\xc3B:\x05\xe6y\x8b\x87\xfd\xf8\xcb\xf3\xc7\xc0[\\\xb5T\
\xee\xdeY\x978\x9e\x12w\xcd\x82\xfcl*\xb1Ya]\r\xc9\x15\x06\xf7\xd1h\x05V\xf9\
2\x0b\x17peu\x9c\xac \x86J/k\xcc\x81\x15\x03b\x83AD\x13\x0f\xbf\x9f\x95*\x1d\
U\x86k\xc2\xb9r\x1d\x90#\xc3\xd0\xeb\xa3\x14\x84(vvtj\x0e\xdc\xae\xc8\xc0P\
\xb1\xa2]q\x1a\xc2\xdb\x1e\xe30\xae\x08$\x0c\xe1O\t\x80\xa8\xffC\xbc\xe2&\
\xdb\x8a\xcd\xd6\xadV\xc0Q\xa3(*\n3\xb6d_-\x18\xca\xdc\xe3l\xb4$p\xad\xa7\
\x9b\xe5R\x15\xe3\xd9G\xec\xd4\xc5\xa9~C\xb3l$\xe5\xdf\x89h\xe4k\xfd\xe9\x00\
&s\xffK\x92\x9e\xc6p\x9d\xd6C\x07\xd2\\\x99NC\x06\x86{\xbf9\x11N\xab\t\xef\
\xaaTw"\xdb\x11\xb8r\x8dl\xc4f\x8d\xa4l\xa9\xd12\xd7\xb3\xaf\xbc;\xb3ek\xae\
\xe6\x81\xdb$\x939\xc6q3t!\xa9P{[\x01\xc6P\xf3$\xb3m\x08\x8a\xb0\xaa\xa8rH\
\x8a\xa8b\xf3\xb9\xc5jk\x181\xdc\xf2\xcc\nE\xa9\xae@\xb7\xc3\x1e\x8eY\tW\x08\
\xe3\xa9\xe5\x8fdfH\xb3[\xdb\xaang\x17\xb9b>\xa0/6d\xe5\xdc\x96\xf2\xf9UV\
\xc7}\xa9\xe5\xad\x1e#\x8f\xb9R\x13\xd9\x1d\x83\x84]\xd9;\xbbo\x03U\x13\x92\
\xc3\xd5\xb9z\x82\x0ft\x81\x81\xc4f\xaf8\x1c\x86m"b=\xabs#Ws0\xa9\x8d\x0f\
\x0cd\xa2\xc4\xafNj\xd4\xa3\xd4L\xed\xb5e>\x9f+X\xe1\x85\xc0s\xf4\x16\x18\
\xa5W.D4\xf9\xe1t\xf5\xe0>\x87(\xabZ^\x81rS\x14,9Q\x8e#_\xcd\xafr\x94>V\xebM\
\x85\xe9\xe7sUq\x12.\xb0\xbe\xf9\x8c\xaf\xbc-\xb0\xc3B\x85\rn\xe5\x8a\xe7oU`\
e\x11\x0b\x8f%\x90\xfd\xa6\xdc\xcf1W42\x9d\x19\xec\xedII\xe2<ri\x06\xc6\xb1\
\x01\xf3\xfe\xb7p5\xefd\xf9\n\xc4\\\xea6\xe6\x8ee\xb1\x05u}9\xe0\xaa\xf7\xce\
\x12S\xb5/\xce\x19\xdb\xda\x95\x1d\xabu~\xa3]-!}6\xc2\x7f=\xcb\xc6\xb8\xf7S\
\xa1\xa2"\xe7\xb9\x859\xb5\x88\x8e\xfb\xa7\x13;\xb51=os\xa3Y\xee\xe1<\xb7H\
\xb9\x02\x06\x12\xd9\xd2IlL\xd4\x1c=\xf0}\xe7\xec\xf1e\\\xcd-\xd3j8\xa0D6&\
\xbbB3i\xaf\xe6\xca\xb2\xd4w\xbb\x010\xf2fA\x13\x05/\xe5\xca\xea\xb7T\x8f\
\x81\x8d\x1eV\xbe\xeb\x10\xf5C\\\x8d\xc8k\x8f\xd8\x84~\xa3\xa1\x0bltF\xac\
\xd7\xd6\x83\x1a\x18\x7f\x8a+9(\x18\x8aD\x9c5\xc0\xd4\t\x8cR\xf7e\\q\xa24\
\x9c\x1e>\x97?\xf0\x19\xf3X\xea\x03\xbd\x9c+cb\x99L`:\xbb\x0b\xc2\xdd\xfa\
\xfd\x03\\!S\xa5~\xba\xaa\x18\xd3\xfc\xf0\xfb\x98\xab\xba\x1csE\xb4\xa6\x0f\
\xa3\x97=\xd1\x1e1\x01\xc6\x92I\xbe\xcd\xe9E\xc9X\x8f\xa0b^\xd8\xdf\x05\xa9\
\xdan.\xbbeL\xa5\xcbk\xc8\xfe\x7f\x95\xb4\x0b\\\xe9\xedw\x88-\x96\x84\xb1\
\x19\xb5&]3\x12\xde\xca\xd5\xda\xa2\xda\xa3\x85\x8a\xec\x19\x93\xbb\xd2\xfc@\
\xd7\x95\x8bv\x053\xd4\x8c\xe3!\x99e\x17\xceaj\xc0V\x977s\xe5`3\x96\xb0?\x87\
)\x02[%\xf7r%\x8d\nd<\xb5\x03cz\x85\x1d0X\x8b\xa2\xa8)\xc0\xb5\xb3[\x92\x13\
\xe9\xd3%\xf3]{U5\xb7q\x0cn\xcd-P!\x94tqm\xf8I\x9bs"\x1dd\xf7\t\'7\xe6\x16\
\xcdjMD\x11\x05\x95\xbf~r_\xe4\xe4N\xa2\xce\xd5\xc5\xf7WJo\xf75T\xa2\x8a\xde\
Y\x8d\xe6\xdcI\xb8\x0b\xb5(\x0f\xbdkT\x07\xba\xb3\xb0\xdf\xc4\xb3\xab\x1e\
\x89\x19\x89\x9d\xf8-\\E\x99\x18\x8b\x92KE\xa1t\xac\x19\xcb\'G\xe5\x98\x91:W\
\'\xef\xf0S\xe7:_Z\xf7\xfa-\xf7Y\x1f\x8c\xccr\xa4\x11\x01X\xf6P\xcaQ\xa8\x0c\
\xec\xfcD\x9a\x8b7\xb1K\xd1\x89A\xf6\x83\x0c\x92t\x0c\x1b\x1d\x9eoW\xde \xb8\
\xaeLT\xfe\x06#-\xb0\xef8l+w\x91o\xde\x0b{3{\xf05q\xd8\xd7\x98s\xeb\t\xa3\
\xb0\xeb\xf6\x97\xe0\xe9?#5L\x98\xbb\x84\xcav?\xd2\x1b7R\xe5,\x85\x83\xacV\
\xbdD\xdb\x15\xca{\xd6\xf7\xf9\nD\xf0a\xc5\xab\xbe\xce\x98i\xb8V&\xa2\x85$a\
\xb1_o\xfa\x97J\xec\x1b\xa09)\xba\x8am4\xef\x0eW`\x96\x04\x1d\x7f\x9f\xbd\
\x1d*\xa5\xd7\xfa\xf9U\xf9\x84\xab\xca\xf6\xc6X\x14;!C\x9e\xddne\xb3b\t\xa4S\
\xa4\xabvU\xe1\xc1\xab\x83\x95O\xdau7\x95\xb1\x82\xfb\xe3\x15\xd8\x8f\xb3\
\xfc\xac\x90\x9f\xcb\xda\x94<\xfd\xf6\xefL\x0b\xa9\x8f\xb3{y\xb1\xb7\xb8\x8e\
g\x8a7Y\xe7\xf1\x8a\x00\x9c\xaf*\xf5\xf7\xd9=3\x8a\xb5>\xc2c?s\xcd\xe5R\x14\
\xce\xdcO\xa5\xd8\x91\xad\xca>0^B\xd7|\xa0\x1c\xc4\xbf_\xc3\xe1z\xba\xb2\x03\
Z\xffd\t\x15|\xa3\xb6LU\x9f\xfd|\xc0\xae\xc6\x91\x85}\xb2\xb6X3\xd5\xe5c\xbb\
%5`\xbe\x1aO\xf6\x16\xa7\x90\x12y\x04\x98\xed\x0c\n\xc1\xe1)#=K\x96\xb6\xc1N\
\x13\xf5_kn;\xfa\x10y\xd3\xec\xf6A\xf9E\xf59\xf2\x8b\xea\xad\x84\xbd\xbc\xb0\
\x0f?\x16U*W\xcf\x98^.i\xb0\xf9N\xae\xfe\x9c&\xf9o.m\xaf\x8d\x95wM\x1f$\r\
\xce?\xc7@r%\x8d\xdcr\t\x00\x00\x00\x00IEND\xaeB`\x82\xa4^\x11\xec' )

def get41Bitmap():
    return BitmapFromImage(get41Image())

def get41Image():
    stream = cStringIO.StringIO(get41Data())
    return ImageFromStream(stream)

index.append('41')
catalog['41'] = ImageClass()
catalog['41'].getData = get41Data
catalog['41'].getImage = get41Image
catalog['41'].getBitmap = get41Bitmap


#----------------------------------------------------------------------
def get49Data():
    return zlib.decompress(
'x\xda\x01\xf3\x06\x0c\xf9\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\
\x00\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\
\x08\xdb\xe1O\xe0\x00\x00\x06\xabIDATx\x9c\xdd\\\xdb\xb2\xe4*\x08\xc5\xa9\
\xfd\xff\xbf\xccy0\xe2\x92\x8bB\xd2}f\xb2\xa9\xael\xdb\x18e\xc9E =\xd3\x98\
\x99\x88Zk\xf4+\xa8\xc3\xf9!\xa2\xd6Z\xff\xf2\x0b\xa8ci4\xf0\xfd\x1aj\xad\
\xfd\xf9\xdb<|\x85~\xae\xbfhW\xcc\xfa\xeb\xdb\xe8w\xcaj\xa0\x12\x81\xa0d\x98\
\xdf((\xf2e\xd5\xd5\xef\x9dx:\x19T\xef\x87D\xbe\xac^\x0e\x89v\x1a\xf8f\xfa\
\xd1\x1d\xdd\xad\xb7\x86\x12\xfb\xa7\xe2\xa9L\xcc`P\x91\x0f,\x19\x7f\xb4\xd6\
p \xce\xb1\xce\xb7\x9f$\\.\xb9\xbf\xc1y\xd5\'=Na\x060\xb3\xf4\xf5\x86\xbd\
\xee\'FHm\x90|=\xf03h\xa0ry9\xae\xef\r\xb8\x805b\xba>K{\xbb\x82\x82\xd4\x9b\
\x92U\xe4\x9d\x98\xa7\x81\x192\xbc\xe8\xfb\xc1s\xdc\x08\x87\nB\x15\xa5)M\xae\
\xd2@\xa5\xe6\xd8OiYnDKL\xc2\x91\xb6`\xef\x82\xf0:&?s\xa8\xd4e\xd5\xc8\x87\
\xd5\x98\xf4\xce\x18\x01\xb6+\xf1\xe9\x8dH\x9e"\xa8\xae\x90\xd3\xae\xd2<~\
\xf7\xbcB[\xef\xd4\xb9\xcc\xc8Dl\x8c\x89\x98\x99+\x92\x0c"\xa6\x08X\xf7\x03\
\xc1=\xf5\x94\x92\x8c\xa5\x8bi\xb8\xe2:O\xb4qE\xd5\x82\xb6,u\xa49\x86;\xd1-k\
a&\xa5x%\xfd\x01TZ\xd5\x9b\x9e)\xc3\x9cx\xe1\xc7f\xbf\x00\xebvX>\xaf\x88\x02\
\xd7f\x96\xa2\x88_\x06H\x8f0\xc9Q\xde\x81M\x99\xa7g@T\xf6\xa9\x9b\xcc\x19\
\x1f1\xa6\x1b\xaebs\xbd\xb7\xa2"@\xa5\xb7C{\xea`\x98\x1e<\xb6V\xc2\x9d\x9a\
\xf2\xc8$O\x00\xae\xde\x82\x83\xb6^3\xd13\xe1-\x90\xf2\xe2\x12`7\x04\x18d"G\
\xc3\xc0\x08\xc7\x1b,\xfcY\x1b\xcb\x00\xbb\xed<;\x05\x99H\x86\xb6\xf8]\x9f\
\x81r\xc8\xb3x\x83j\x11\x93fk\xcb\x9c\x02\x86_\xbf]\x03/\xa0\x8a\xb4_\x8d\
\x91N\x97\xefH-?K\xb5*\xa7\xd5{4e\xe9\x8fD\x81\x87\xcf\xd1\xa8\x9ePj\xe7V\
\xbf\x14\xf2qd\xe8\x86\x7f\xc7g\xb9g<\tn\x0b\x1a\x18\xf9(pw\x0e\xb08\xb4\xed\
w\x9d\xe4W:\xd5\xb3\xf9-\xc9\xca*\xd2\x10\x93h\x9cc`\xdc\x05\xc1\x00\xea0;\
\xc9@\xcd\xe8g\xedM\x8fR6\xcc\x9d\xb0&\xb1\x14\xea\xcd\xf9\x8c\xe7\x18\x06{p\
Ww\xda\x9e#\x15d%\xed\xcen#Yl@\x9a\xac_\x9d\x92\xf8?\t\xef\xc6n\x12QVV5\xcfN\
\xb0\xf7(\x9c\xb1\x9d:<E`T)u\xab\xca\xcc\xe8\xb9\x93\x89\xec\x97iJ\x9d\xda\
\xe5\x91\xa6\xd6\xc9\x98+~#\xa2E\xaa]\xbb\x0e\xd7\xdex\xe8\xdb\xd3\x1a\xa8\
\x9eY7^$&\xfa\xb6\xc6\x89\x05\x1e\xbb\xb2)\xadF\x97\xf8a\r\xa4\x00\x8f4\xac\
\x03T\xd6\xb8!\xf4x\xb8G]\xd4\xd5\xa3\xb9bW\x01\x1e\xcb\x9f\n8\xe8X_\x1c\x19\
\xc7\xdc\x17\x0fX\x9e\xd5,*\x84d\x05baH{_\xb1\x1f\x92a\x94R\x1f\xcf\x06X\x9e\
\xb2\xde\xc2\x85$A\x9d\xdcR\xc3x\xbc]\xb9\xc6\xc3\x07!\xe1B\xf3A\x1a\x12\x1b\
\xcf\xe6\xa9\x1a\xdd.\x07\xeb>_Z\x1c\xc6\x96\xadE\xf7\xd0V\xc1\x9d~EV4 \xa9\
\x9dK\xaa{3\x1fWPj\xad+\x89\x83F\x92\xf2\xe7\xd5U5\xdb\x03\xb3G\r{\x9fu\xe6E\
PT9\xac#\xaax\xf6v1\xc5M\x9a\xa3\xb0\x1a\xd7\xbd\\QF\x822\x80\xc7\x0cp\xac\'\
9-\x9c\xc2W\xf83\xbe\x1c\x97\t\xfc\x81\x16\x8e\xff\xec\xba\x10\x9c\xef\x1f\
\x8d\xd9I\x84\xd3\xa8\rH\xcc\x8bR\x8dr\x06\xe7\x0fM;\x90a\xa1\xfe\xbd\xea\
\xd9\x0b\xe7\x95j\xe7WJz\x14\xd1aTo^\xd5>I\xe9\xf3\xeaZx6&\xd3\x1e\xbc6l\xc2\
\xf5\x16n\xfc\xba\xe4;cQ\x94X\x9e\x9e\xfe\xe6L\xf9.eE\xd6\xa1\xdb-\xd0\x89f\
\x00\xac\x14\xc8\xa7=\xfb\xe0\x00\x1b\xd12\x12(\xed}zD.\xb0\x92\xbb\xafd\xf8\
F\x0f\t\x16\xdb\x9f\xaa\xb4J)\xf2\x816XiuHT\x8b-\xfaz]\xebxf\x87jIt\xdcV\xeb\
\x981w\x96GT6\xd0\xd0\xc1DQ\xf5\x86\xca\xf9\x15\x9a;\xb7\xc9\x1f\x86\xde\xb4\
S\xce\xd3\x12\x1e\x1eZ\xe3\xb5#\x95\xeb\x81\n\xd8L\x84f\x82x\x98\xc4r\xef\r\
\x9b\xedk\xe3\xf2\x8cVe\xe5\x02CH\x99\xc3\xd7Vlh\x99\nG\xce\x01%*\xc5\xecS\
\xddm\xdc=*A\x87+Vu\x94\xb4\xb0F\xd0\xb32\xe56?\x1f\x07F\xb7\xaa\xc50\x96`\
\x12\xf6\x85 \xb0\xc0R\xcc\xc2%\x89\xdd\x9e\xb9\xcdj 3wt&\x9fON\x00S\x010dE\
\xa9\xa2\x8c\xa4\x9cb#\x15\xea\x81D\xb3,<\xde\x1b\xccpv2m:U\xb4\x81\xec\x06\
\xa1\xd3\x1c\xec\xbeF8R\xben1+\xe0\xb6gS(\xb7y\x97\n\x9af\x05f9\xd6\xd8\x14E\
\n\xc0\xee\xdb\x95\xfb\xceB\xc6\x9fJKa\xc6\xe5\xddZ^p~\xd4\xaeL\xc6\xa6\xdeY\
\xd0\n\xde\xe2\xd9pc_\xed\xb9\xd7$\xab\xf4$fG%\xd9\\e\x8c\x9f\xff\xaf\xc1\
\x11"\xbc!\xa5\x0f\xa0\x12\xb6">\xf0M\x97\xcb\x90\x92\x8f\x02\xa6&/qu\xf7w\
\xb79\xda0t\xaa%.\x81\xd5\x17\xeb\xec7\x08\xedA\xb1u0\x95\xe1\x19\xabR\xea\
\xf4wdu\xb0\x13\x89\x9a2\x90\xbcaeTj\xef7Fe\xadB=\xebcF\x01\x1e\x81\x05\xf8\
\xcb\xdeB\xa2\x8a\xf5\xe4\xcd\xfe\xea\x0f]\x88\xc7e\xa2\xc7\xbd\xb5\x0e{\xe2\
\xd9\xcb\x81\x8cq\xf7\xbc\xc0\x9b\xf5$\xa4\xa0b\xa6\x07/\xc3>\xf3\xef\x1aK\
\xe2\x82\xa7n:\x03"\xda\x8b\xb5Zcj\x83\xcb\x8b\xad\xaa\xb8\xf4\xb4bZ\xcd\xd6\
\xd4`qg\x15\xbb\x1d\xb3\xa7\x10\xdd\x12x-\x01\xf6\x84f\xe8\x98\x99K\x8daZ\
\x81-\xbf\xa7\xadU\xcep\xa6{\xc00)\x9e\xc2\xc9\xe8\xa1[\x8fw\xdbO\xecJ\x02s\
\xecQW\x8f\xb7 \xa8c\xf6\x94\xea\xba\x17\xc2\x0e\nZ\xe9\xb7\x07r2\\u\x98\xd4\
\xef\xf0]W\xf1\xc0Cx\xe4\xcdv\'\x13qs*\xb2I{\xbf\xce\x84\xe5\xa4\xafL\xd4l\
\xcd/\xf8\x01\xfa\x96>\x131\xb5Qgh`)\x8cAB\xfc\xe0":\x0f\x94\xfb\x18\x0cp^\
\xbf\xdeG\xa5\x0554\x1c3v\xb9\xc5\x01,\xff\x14k\x15/\xe2Q\xe1\xbc\xc2\xe4\
\xcf\xcd\xe7\x15\'h\xc9M\xca\x12\xbc\xb4\xfd\x13o_\xd4\x8e\xd6\x80F\xed\xbc"\
S\'\xd9\xbb\rwu\xcbI\x08l\xcbP_\xde\xbd\xf9\xb4\xca\xf9\xff\xd3\xc2-\xbe\xbc\
\xa0\x0bj\xb6\x1a\xf3a_\xfcA\xe2\xf5\'E\x83\xde\xff\xbfvx;\xfe~T\x9eu\xbc\
\x1c\x95\xaa\'\x0fz3\xaa\x00\x12\xbd\x15\x95\xf2\x10P=\xee\x7f\xdf\x89\xeaD\
\xdf\xad\x9c}\x8b\x9c,f\xa1\xdf)\xab?\xd5\xd7\r\xff8]\x19\xdd\xe6\x85\xc5\
\x1b\xa9\xc3\xf9\x0f\xbe\xf8\xc28\xe4\x99\xb0{\x00\x00\x00\x00IEND\xaeB`\x82\
\x023r_' )

def get49Bitmap():
    return BitmapFromImage(get49Image())

def get49Image():
    stream = cStringIO.StringIO(get49Data())
    return ImageFromStream(stream)

index.append('49')
catalog['49'] = ImageClass()
catalog['49'].getData = get49Data
catalog['49'].getImage = get49Image
catalog['49'].getBitmap = get49Bitmap


#----------------------------------------------------------------------
def get45Data():
    return zlib.decompress(
'x\xda\x01A\x07\xbe\xf8\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x06\xf9IDATx\x9c\xed[\xdb\x8e\xeb \x0c\xb4W\xfb\xff\
\xbf\xccy \x98\xf1\xd8$8mw\xb7\xd5\xb1\xaa*%\x04<\x8c\xf1\x85\xb6\xdaZ\x13\
\x11U\x95\x8f\x90\x0e\xe7[DT\xb5\x7f\xf8\x00\xe9XT\x06\xbe\x8f\x11U\xfd\xfam\
\x1d^"\xdf\xee\x13\xed\xae\xb7\xe5\x10\xb8\x8a\x0e\xe3m]\xc877\x18?o\x0bI\
\x1cW\x1f$\xffQ\xbd\x8f|&\xaa\xe0-2\xf9S\xf9\xd4N\xce\xb0\x85\xaa\x8f\xa5\
\xaa\'\x03\xaaJ\xbf\xa9c\xe2#y\x19\xef"\xd2\x9a\xa8>\x94\xcal\xaeo\xc1\x02[k\
iHK\'"H\x86\xa4\xb5=\xcd\x1e\xb3\x8e\xc0Uq\xb8\xd5\xba\x1b\x0c\xe4Ju/]\xe9:\
\xec\xf6N\x04\xb8\x8aC\x84\x96H\xd7\x8a+\x19x\x88\xab\xae\xea\x19]x\xeb.c\
\x9e+J,6V\xab\xdf\xb7\xd9u\xec@\x01\xba\xac\xc5\xc6\xee\xc0\x92\r\x16Q\xa8H\
\x9d\xb0\xc5\xbe\xda\xa3\x1e\x89j\xb3\xf1\xa0\xc8\x8f\xd7\xe4R=\x95\x1cV\x9d\
\xb0\xcc\x07\xf6\xc5\xdc\x00\x96\x12%\xe0\xa9\x88%\x9a\xe1u\xd5j\xe0\xcal\
\xefJR\xa2\xc4W\xd6Q\xef%\x08\xd5\x8c\xa8\xe3^u\x83yT\xba\xb8\xce\xa4\xd3\
\x89D\x8d\xf6\xd6\xdfq_EN\x9c\xdbx\xb6\xaf\xc7\xfaJ\x18V\x12\x9d\xd4\xac.\
\x12\xb5\xb27\x92\x84\xae\x1d;\xac\xd8*r\x95:\xa0\xe5\x14D\x14\xa5\x11eimm\
\x9e[\x9b\x1c\x05Q\xc5\']\x0b\x12e\xef\xf4\x0cm*\x01\xcf\xf1\x93\x82QX\xbc\
\x92\x8dT\xb6\x10l,Q\xe2\'>\xf5lC\xe2\xac\xc7\x83\x14\x91s\xe7\xcfj\xec\x88\
\xf7\x16mq\r\x8a\xda\x8eJrY\xcf\x8c\x0e\x91\xc1\xf3\x9d=w\xcb\xf3\x07\xcf\
\xde\x97vm\xc7\x18O\xd5\x93\xd3\xd3\x00\x0cV\xe2;\xc8\xb5g\xf5S?!\x0f\xdc\
\x1b\xabs"\x1eR\xa7\xc2\xd8 `X\xc2\x1c\x07\xab\xe7r\xb5\xb2\x97\xb2[_uAH\x12\
r\x08KHT/\x9cD\x8d\xb1\xba\x14P\x11$t\xe2\xd1\xa7\xa3Vs+n\xfb}b\xbb*\xbb\xa8\
RH\x11XTK\xbc\xa1\n<\xbe\x9aH\xc4q~\x03\xd8v\x85\xdf\xa7\x1c\n\xa5\x01\x17\
\x95f\'\xe1\xf1`\xc1\x9f\xcce\x91\xe3\xc0\xc6\x05\xf5\xd3P\rHs\x8e\xb8\xf0P\
\xf3\xe6<\x10\xc3#^\xc1\x14\xc3\xaf`\xa1\x17\xa9\xbe\x94\xdds\x8b\xe1\x1e\
\x92\n\x02!\xa5e\x95W\xba\xf9\xe5p\x81\xd8\xe2!T\xad\xecE\x9f\x89j\xcc\xbaU\
\x1aY\xa4\xb2n\xab\xad\x05\x9c8\xeb\xc5\xa3\x84*$)\x9e1\xb9\xc2\x9fj^oZl*\
\xd4\x82\x90P{\xea3\x86=\xd8\xdb\xdfW\xbb\xa88\xf7\x1b\xc0b:\x8bH\xa2G\x81\
\xf3\x19\xb7\xa3\xa8\x88\xc6k\x8b\n\x9b\xaaJ\xc5\xb3\x1f\x90\x86g\x9fG5`<\
\xec\xd3\xa2\x7fO\xbd_\x1a\xfab\xee\xff\x12\x1f\xc8\x90\xe6*\xf6\xb9\xa1\x8e\
\xcc\xa6\xa7@t"\x06`\'\xbe\xa5R\x88W\x08I\xecH\x0bN\x9b\x87N\xb9\x0b&<6`\xda\
\x93\xce\x12\xabE\xda\xb6\x05\xce\xf9\xa6N*\xd2f\xf8r\xda\'#\xf8\xda\xcc\xdf\
rg\xf1\xd8x\x0fX\xc5\x02\x9b\xd3\x8c\x80u\x82V\xe9\x82dh\xd1m\xa4\xf6y/]\x92\
\x1b>\xd0D\xad\xa2\x03\xd7\xa1\xd9i\xaf\x1dr\x9c\x036H\x18\xe2n\xa4KR\x89W8\
\x93W}\xb8y.\xef\x83\xea\t\xe0\xe0r$\x1cx\xdc`l;c:I\xf0\x06W\'\xa6\x8fy\x10\
\x8e\xa9\x00\x8c\\(1\xb6\xa9g\x97}\x0bt3\x1d\xf4\x98\xca\x81\xab\xf08s\xd5\
\xf1\xb4\x994\x1f\xdd\xc4\xaf 2\xf6|T\xe9L2\xec2r\x05Nq\x12u$>\x03\x0f\x9fay\
\xdb~\x84\xb1\x9b\\\x891$\x8b}\xb5~\xcd+uD\xf5q)e9/m\x1eE\xb5\xb0\n\x07\x8c\
\xe7\x9e8h\xac\xf1\xc2\xbe\x83\xf0K\xc6\x9e\x89j5\x87\x03\x06\xa1l\x863\x9d(\
\xe2k"\x1d\x84?\x85\xb1\x9a\x05^0\x86\x02`\xccU\xa0\xc3h~\xed\x8d+\xd2\xfd\
\xe5\\\xd9\xa0)c\x12s\x0e\xc4\x98yvq\x1d&W\x02\x9e\xe3\xb5\\!\x9et&\xcb\x0f4\
\xf0 \x99gOF6`\x8by_\xb5\xaf0\xcc{\xc6\xfa\xdd\xde\x9e}e\x14Cp\xac\x11\xb1h\
\x1bO\xe1\xeeZg\xf9,\x05T\x94\x92A17!ab\x8a\xcf\x9e\xa4\x82\x13\x08pE\x06,\
\xa7ys\x94\xda\x894\xcc\xe1\n\x87\xc1\xd2Q\x92$\xa90\xa4\x0eQt\x14l=\xe8\xf5\
\xa11\x99*A\x92;\xe7\xec\x83.<\xd6\xa3\xbbQi*1H\xa0\xa6:\x061`\x12\x8a\xba\
\x1d\xa9\xa1\xc2S$\x04\x96\x8a\xe9$@f\xd2-T\x9c\x87\x15P\x8a\xb8\xbf\xabnp\
\x85\xca]V\xa9\x90\xb6^$r\xb8\xeb\xa0\xd0\xba\x03I\x8a\xb50\x1f\xf7\xe1i&^\
\xa0\xa2)\x9e\xb8\x16X\x86\xd09T\x0b\xa6x)5\x1f(\xb0\x0783\xa0\\~@R\xb40\xd0\
;\x044\xc7\xbf\x15;R\x87T@\xa5\xf6m\xe2z\xf9\r\x8f\xc8\x84\x94\xf6\xa1\x96x\
\x008l\x1b\x82{\xc5\x04\xabQ\xd8i\xafCHi\x82\x94\x9eW^&A\x08\xacX\x88\xd4,p\
\xb2dK8\x08\x9c\x00(GM\xed-l*<9k\xa1}0\xb6\xadj\xedw\xb7\x08\xc9e\xb4\xac\
\xf4\\`\xf2\x93\xd1\x08W\x95\xbc\xed\xc9c]\xb6!\x15P\x89\xdf\x03\xe2\x03Q\
\xe8I\xd9\x06\xc7\x03\x1cs\xd5nx\x0c\xd2\xab\xe2\x15Ny\x12XMh\xe1\xc7u\xd2\
\x81\xfa8\x9b\xec-Y<X\xc9\xfd<\xb0\xd4\x19\xed\x96\x14\x83t\x89\xbf>\x17\x0f\
i\x7f\xc6\x9b\xa8L\x91\xb3\x9ai\x91\x13\x90?\xb0\xfd\xd9\xfcW\x98hx%H\xf2\
\xd0?*\xa8\xf6XH\xe3\xb3\x00\x17\xeb\x1aT\xbe\xe8u\n\x902\x05\xee\xa2\xc2\
\xb16\x80\xf9G9\xed\n\xc7\x01\xf9/p\x96j\x84\x0e\xb7,0\xa9u/\xa2I\x03\xa2\
\xd2\x0c\x03\x8bQ\x84dY|\xc2\x98\xfak\xb8_\xe7J%\x87\xe5\xd2S\x97\xc2qW\x9f\
\x91\x88\x0fV\x04\t\xa2"\xd5\xa1\xc2\xb0\xe0\xd3/\xfcS\x89\x18K2\x8f\xa3\xdb\
|\x8f\x81~a0\x87\x14Q\xcd\n5\xb9WN\xd7D\xc4\x07\xdc6\x1b\xf3C\x0e|\xee\xa4\
\xa5\x82jG\xe9X\xdeo\x0c\xec\xc2\xd4l<!J\xce\x7fO[A\xb5\x134fV\x95t\xc7\xedd\
\xd7\xd3\x19\xc2\x18WD\xf9\x07\x84\x99+Z`kkg\xb7<\xc5$\xf58\xd4bP\x86y\xb6\
\x02/n>\x90\xc7r\x8b\xb3\xe9\x96?\x80\xa1k\xcc\x8c\xc4\xfb\xbd3\xc1\x94$H\
\xdd\x07\xb2A\x8f\xd6\xf3\x04\xe0\xd0\x84\xcb*\xc7\x9b\x8d\xb5\xff\xab\xfc\
\x85\x99\xde\xf2\xecg\xee\x07\xda\xc2\xee\x8aYy\xdd\xf5A\xd71P|\xe6n\xbc\xf2\
\xca\xae{9`\xaedZ<\x15\x89JB\xb0d,\xe9\xedxE\xb3\xc9\xa5\xf9S\xdf\xe4gWQ\xb7\
B\xd8k\xf9w-\x8f\xe5\x16\x1b\x90\x1a\xff~1\xf9cj\xd436n\xd6\x8b\xc7D\xb2Q\
\xbd\x94F|\xb54:6\xe9\x02\x1fUu\xcb\xb3W\x8b\xb6_\x97\xcf\xfc\x1f\xfe\x7fT\
\xef#\x9f\x89\xeaUy\xe0\x0f\xc933\xa6\xbf iP\x1b\xf2\xce\\\xad\xe3\xcd\xdbru\
*_\xfb\x87\xd7o!G:v\xf9=\xf4{I\x87\xf3\x0fF\xbd\x0b\xb6\x1dC\xd2\xd5\x00\x00\
\x00\x00IEND\xaeB`\x82\xc6\xceyq' )

def get45Bitmap():
    return BitmapFromImage(get45Image())

def get45Image():
    stream = cStringIO.StringIO(get45Data())
    return ImageFromStream(stream)

index.append('45')
catalog['45'] = ImageClass()
catalog['45'].getData = get45Data
catalog['45'].getImage = get45Image
catalog['45'].getBitmap = get45Bitmap


#----------------------------------------------------------------------
def get38Data():
    return zlib.decompress(
'x\xda\x01\xed\x02\x12\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\
\x00\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\
\x08\xdb\xe1O\xe0\x00\x00\x02\xa5IDATx\x9c\xed\\\xdb\x96\xc2 \x0cL<\xfe\xff/\
\xb3\x0f\xa8\x8bri\xc8\x85:\xd89\xfb\xa0\x1ew`\x9a\x90\x84\x14\xcb)%"bf\xda\
\x02Y\xce\x9d\x88\x989\xbf\xd9\x00Y\x0b\xd3S\xdf6`\xe6\xdb\xd9s\x08\xc1\xfd\
\xffe^Z\xd9n\xe52\x03\xb4d\xcbV\x1f\x91\x030\x90\xf4=0%D+e\xec\xb9\xae.U8\
\xb8\x1f\x7f\xa5F3B\xaa\xc3\xa6/\x1b\x11il\xd5\x8c\x90\xea\xb0\xe9\xcb\xf6\
\xc4\xa4*\xf5t\x17\xb0\x15\xf0XW\xbe\t\xcd\x83\xad\xbf\xae\x00\x93\xef\x0b-[\
}\xacN\xc0\\\\\xd8\xaa\x9c=\xa0\x92\x12\x93\xebJ\xaeV\xf2M_\xb6\x02{f\xe1wU\
\xcc\x8f\xbf\x8f\xd7%\xd6\x1ba~9T\xfb\xab\x1a\xcc\x8d\xf81\x88\x90\xe3\xfa\
\xa0\xfeP\xc86\x83\x8e\x07\x1e\x86\xf5\xde`\xcd\xd9\xd3Q\xd1p\xc86\t\xc3\xba\
\xaa\x87\xecI\x1a` \xcc\x10\x87m\xd1b*\x19L\xd9\xdf\x96Z\nU:7x\xad\r\x178\
\xb1\xbd\xdbJ\xe7\x06\xbe)\xdb\x83\xad\xf2\xc0-*\x8c~\x1dh\x91\x14V4\x08\xd1\
\x89\x16\xb0V\xca\x08\xab\x98\xd6/\xc8\x02\x91u\xa0$x\xc6 \xb8\x1b\xd3\xab\
\x86JI\x90\xdd\x98q\xb6\x00\xee\xc6\xf4\xb2\x05|7F\x9e-<\xfa%\x0bw\x8d\x0b\
\xb3\xc5/\xec\x85w\xc1\xd5\x8d\xc1\xc1\xbc*\x84n\x8c\xcaV\xbe\xa5P@a\xa5\xf5\
@\xdf\xfe\tF7\xe6l\xb6\x85\xdd\x98\x85l\xe6\x18\x08\xd0\x8d\xb1L\xc5\x0b!\
\xdd\x98-p\xa9\xc2\xc1\x9ew\xbb\xcd\xaa\x9a{\xf2\xb3\xd9l\xaa\xca\xe1\xed\
\xc2\xfc\xd8\x0c\xaa\xea\x81-Sqe\xd3\xaa\x1a\xdc\x98<\x9dM\xa9j<\xd8\xecT|\
\xd9\x88\xc8\xa1\x1fh\x9c\x8a/\xdb\x13W\xbe\xa2\x9f:s\xf6}\xb8T\x19\xb1\xf0h\
\xde\xaa\xfd\x95\xbc\x14:a\x7f\xa5k\x89\xf5J\xa1/\xear6\xcfD\x0e\x0eJ\x8eK\
\xa1Y6\x19\x82\x7f\xa9\xe4}\xecJ6f\xe8/\x95\x02J!!\xc2T\xc5\x94BB\x80\xe7\
\xab\xceu\x89Q\x15V\n5\xfe\xb7\xc5\x00k\xab\xe1\xc6\x19\xb3\x1bs\xb4q\x06\
\xec\xc6\x086\xce\x0b\xbb1S\x87=\xbf\xb1\x1b\xa3(\x850\xba1S\xa5\x90\xba\x1b\
\xd3\xb9|\xaa\x8a\xc9\xeelF\xb6\xf2\xdaU\xd7\x91\xf3C\x05\xe6T\t\x1dC\xc8\
\xe9\xcb\xf6\xa0\xdc\xf4\x17\xeb{vcT\xa7\x1eOG\xbdC\xcb\x9f<\x1d\x15\xd0\x03\
\x05g"\x01Ue\xa4\xd1c\x02\xae\xbb\xddSC\x82\x9d9\xf3\xed\x9f\xc4tcT1\xb09\
\x8c\xdas|\xd9\x88\x088Z\x0cq\xa9\xc2\x01fmA\x075\x14\xa0\xad\x04\x11\x12\
\xd3VGG$\x01m%\xc0-\xa5\xb4\xcd\x03\xe9\x88\xe8\xf1\xf4\xb6-\x9f\xb4\xf7\x07\
\x1b\xbd`\xc6\xc4\xf1\x0e\xe0\x00\x00\x00\x00IEND\xaeB`\x82\xb1?c0' )

def get38Bitmap():
    return BitmapFromImage(get38Image())

def get38Image():
    stream = cStringIO.StringIO(get38Data())
    return ImageFromStream(stream)

index.append('38')
catalog['38'] = ImageClass()
catalog['38'].getData = get38Data
catalog['38'].getImage = get38Image
catalog['38'].getBitmap = get38Bitmap


#----------------------------------------------------------------------
def get06Data():
    return zlib.decompress(
"x\xda\xeb\x0c\xf0s\xe7\xe5\x92\xe2b``\xe0\xf5\xf4p\t\x02\xd2\xee@\x9c\xc0\
\xc1\x04$\x0fT\xff8\x06\xa4\x98\x8b\x9d<C888n?\xf4\x7f\xc0\xc0\xc0\xf8\xc2\
\xd3\xc51\xa4b\xce\xdb9\x07\xfb\x0e+\xf0\xb8\xbc]\xf5\xff\xff\xe9/\r\xd3\x96\
2:O1\xc8k\xaf\xca\xeb\xbc\xd52}#/{\xcf\xb2)..\xa1\xa9\xdc\xa9s\x96w\xac\xc8\
\xdaw\xc3a\xa6\xeb\xd3\xfe|\xe9\x95\xaf\x1e_NnxQ\xb9\xa7\xd0\xc3\xc0O\xfa\
\xfe\xde\xacl\xb6t\xd1\xcc=\x93N\xc9\xfb\xa9X\x06\x15\x1e\x8b\xd6\xde\x1duAJ\
U-\xd4\xf1Q\xc9\xfa\xe9\xe1\xdc\x13\xb3\x0e\xef~\xd9\xf53\xab7\\aI\xd1\xcd\
\xbd;\xa3\xdcR\xcf{\xac\xba~\xbf\xea_?\xc3\x86\xb8\xb8\x87E'W3\xf1~\xee\n\
\xdb\xbf\x81\xef\xc9\x9a\xc7k\x13\xe2\xe6\xfewh\xf0\xff\xc9-\x18\x11\xfe\xed\
\xb7p\xf8\xdf\t\x07\xf3\x19V\xed\xd9\xe4V\xb0\\\xa5\x8f\x9d\xd7\xfb\xf1M\xab\
\x0f\xfb\xd6,T\xd6\x9e\xec\x1d\xb7\x95\xe1A\xd2\xebP\xdd,\x9e?\x7f\x02\x03\
\x17:\xab\xda\x1fO\xf5\xaa\xf9\xce%\xab\x15\xb7\xb9F\xb8q\xdfB\xa6I{\xd3\x96\
\xbb\nm\x8e2P>\xb9N{\xd9\x82G\x81\x01\x1f5VT\x88\x84\xd8pi\xc9\xb1\x8a\xf67u\
\xb9;\x1e]L@\xd8\xc5/\xf5\xcd\x8f\xe4e\xaf\xcc\x8c;8\x0cCy/7\xfc\x0cZ{K\xc9\
\xea\xf5\xcb\xe2%\x9b\x98\x9f\x9d*n\xfb\xbewE\x1b\xe3\xe6\x18\xbd\x90w\xbe\
\x0b*\xb4\x8e\xb4}RJ>.?#\xcb\xe6Kv\x82\xfa7ve\xebk\xfe|U_oo\x7f\x1b\xd1\x1eX\
\xbb\x85y\xc3u\xed\xef\x7f_\xd5uhM\xfa\xde\xe3\xe0\xb7~\xd3\x9b\xcfL5{\x9dD\
\xa2\xaf\x9bZoa6X\xfa\xbf\xef\xd9=\xe7\tq\xb2m\xb7s3w<\x9ew\xf7,\xfb\xb9\xd5\
\xef\x16L?\xf2p\x83\xe3\xc4\xcdl\xe7\xaa\xf4,Wn\xca9?se\xd7\xac`\x81\x19\xcf\
\xb5\xabW\x1e}yu\xcd\xf2\xfek\xab\x13\x15\x9f~\xc9Z\xe6\xee\x959\x9b\xf9\xe5\
\x929\xf7\xb6=\xf5\xac\xd6_\xb9i\xd6\xd9\xaf\xf6\x07d\x81I\x80\xc1\xd3\xd5\
\xcfe\x9dSB\x13\x00\x9ev\x07\xec" )

def get06Bitmap():
    return BitmapFromImage(get06Image())

def get06Image():
    stream = cStringIO.StringIO(get06Data())
    return ImageFromStream(stream)

index.append('06')
catalog['06'] = ImageClass()
catalog['06'].getData = get06Data
catalog['06'].getImage = get06Image
catalog['06'].getBitmap = get06Bitmap


#----------------------------------------------------------------------
def get10Data():
    return zlib.decompress(
'x\xda\x01]\x02\xa2\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02\x15IDATx\x9c\xed\x9c\xdbr\x84 \x0c\x86\x93\x1d\xdf\
\xff\x95\xe9\x05S\xcb!\x80U\x12\xf7\xcf\xe4\x9f^T\xdbq\xf3\x99\x03.\x118\xa5\
DD\xccL.\x94q\x0e"b\xe6|\xe0@\x99\x85\xe9\x97\xcf\x8d\x98\xf9\xf3\xb6\r*:\
\xaa#1\xbb\x00=\xe9\xd3W\x12UJ\x7f\xfe\x01t\x14\xb5\x11x2\xe4P\xc4D"\xd9W\
\xe0H$P\x9d\x05\x83Y.\x1e\x08:\x16\x7fg~\xe4\xb4\xf2\xbe4\xe1\xdd\x9c\xdc\
\xaa\xceW\xb9T\x94\x05\xe3\xb6\x1aW\xe7C\xf1\xe4n\xa9U\xf6\xeb\xe6*\x80\xd5T\
\xda\xb9d\x95\xa8R^\xc1\x16\x89S\xb5\xaf\xfa\\\xc2\xac\xef\x9d\xaf01\x1a\xa9\
U\x8b\xebwG\xe1>\xfa|\xba\x1d|\x13I\xa9\xfa\xfd\x9e\xca\x8bL\xfeGA\x85\xafF\
\x16<)\x89s\xa3\xd5rx\x10\x81\x1b\x8b\xfb\xc8t\xcd\xb2d\x92W\xe6\x03\x86U\
\xb5(1\xf4\x07\x8f\x82J;T\xf2uL\xc6C\xdbg\x0b\xab!^\xfa&bn\xc4v\rfc\x08\x18\
\x89\x86\xd5\x02\x19\x89\xbc>1\x05\x15\x8e\x82\nGA\x85\xa3\xa0\xc2QP\xe1\xc8\
\'\xd5\xaa\xd3\xf3P\xdf\xd2\xe9\xd9\xa8\xe8\xf4\xec\x95m^Yu[|V\x8b\xa0\xc2Qt\
zp\xa4Iu\xc5\tx\xa30}[\xa7g\xa3\xa2\xd3\xb3K\xee;=\xdaz\xad\xd3\xa3\xad\xd7:\
=.\x14T8\n*\x1c\x05\x15\x8e\x82\nGA\x85#p\xaa\xc1\x04#2\x958\xc5MD\xc0T%L\
\x07\x869#\xdd_\xa7>cH5\x0e\x98;\xd7\x99\x9e\xb7\xa2\x9a\x06\xccv\x99P\xad\
\x02f\xbb\xf4\xa94^(?5\x982P\xa6\x9a\x9b~\x0f\xec\xc2\x04\xa3\xe6\x8a\xf5\
\x8bF\xef\xfet\xb7+\xd6}\xf6\x85\x95\xdfL\xd0Ss/\xea0\xc6\x8c\xc0\xd5P\x01\
\xeb+\x1a\xbc\x96BDNf\xa4\xbb\xd5\xcd\xd1\x17\xfe\xaf\x1as\xc5\x9e\xc8\xc3\
\xe5\xf0\xe7O-\xe5\xbc\x12\x8d~\xee\x9c\xd5\xdaB\xcc\x1aH\x8b\xadE`\xa9h\xb6\
\x0f\x07,U\x89\xd4\xa5\x16\xe6xUn-"\t\xd6WSa\xfajUE}\xfa\xea\x93Rr\xb3!\x1d\
\x9d\xbb\xb7\xb9\xdci\xef\x07\xaf\xdf\xc6\xb9\x88\xfe~\xd2\x00\x00\x00\x00IE\
ND\xaeB`\x82+\xaf\x19\xa5' )

def get10Bitmap():
    return BitmapFromImage(get10Image())

def get10Image():
    stream = cStringIO.StringIO(get10Data())
    return ImageFromStream(stream)

index.append('10')
catalog['10'] = ImageClass()
catalog['10'].getData = get10Data
catalog['10'].getImage = get10Image
catalog['10'].getBitmap = get10Bitmap


#----------------------------------------------------------------------
def get14Data():
    return zlib.decompress(
"x\xda\xeb\x0c\xf0s\xe7\xe5\x92\xe2b``\xe0\xf5\xf4p\t\x02\xd2\xee@\x9c\xc0\
\xc1\x04$\x0fT\xff8\x06\xa4\x98\x8b\x9d<C888n?\xf4\x7f\xc0\xc0\xc0\xc4\xe5\
\xe9\xe2\x18R1\xe7\xed\x9c\xbb\x9b\x9a\x15xZ\xcc\xe7~\xfe\xb7\xfe\xcc\xce\
\x05V\x81\x9dJG\xe6/\xbd\xb9\xfa\x9a\x95v<'c:\xc7\xa4 &\x05%\t'\xc9\xe7\xfc\
\r\x1dO\xf4\x9956s\xa8\xedKTQ\x9a\xbf\xfcvAg\x8e\x96\xe0\x05>\xb3\xe6\xaei\
\xea\xab]\\\xfbZ\x98D\xed\x85\xae\x85\x18\x0bU\x86\x85\x84,VP<\x7f(\xfb\xa5\
\xc2\x99\xf9\xe1s~\xb5\xfd\\\xfe\xe8\xa8\xd4\xcf]\x8c7N\xbf1\xed\x9d\xb1_L\
\xff\xde{3\xcf\xaf\xa1\x1b\x9d\xcb\xaa2\xe3\x95\x8e\xff\xdf\xb8~\xf6\xa4\xe3\
\xb7\x0e\x99\xe7V\xed\x90={hNg\xdd\x99\xd2\x04M\xf6&\xbb\x9d\xf3\xdf\xac\xae\
\xba5\xcb\xba\xf6\xee\x94c=\x07\xceve\xd61^\x9c\xbf\xf5\xdd\xfb\x96u\x917\
\xbc\xca\xd3\x0f\x9e3;t\x9d\xd7\xe1\xf7\xef\xa9_7l3y\xfc\xfa\x9a\xe9\xbam\
\xfdoN\xceY\x97W{\xd3\xc9~G\xbd\xd1\x87\xe2\xe0\x90\xdc\xc4\t\xf5_g\xdd\x9fs\
gZ\xedU1\xb6}\xc1\xdb\xdao\xab1\xd56\xbfR\x9czlj~\x80\xad\xa2r\xb4\x81\xf2C\
\xf30\x9f\xc5\x1a+*DBl\xb8\xb4\xe4XE\xfb\x9b\xba\xdc\x1d\x8f.^\xf0(0\xe0#~\
\xe1U\xe2\xa7n|<\xee\x13\xaa\x13\xc2\xe0\xe0\xb3U7-\xf0\xd1\x1a\xdb\x1b\xf76\
\xef\xb9\xe4\x9b\xda~04O\xf4w\xf3\xef\x15e\x87\x1f8n\xe7[\xb5\xd8\xa0\xe2\
\xc2\xda\xa9\xab\xeaf\xffX\x9aw\xaco\xbf\xda\xaam;\xbe\x17\xad\xbe!_\xb3/i\
\xef\xa6\x8bS\xe7\xed\xcb\x8b?=\x7fu\x84\xfe\xaa\x9d\t\x1f\xd9\xccU\x17\xff{\
\xf5\xd4jU@/GM\xff\xb3\x7f\x1f\xcf\xbc\xb9f\x1c\xf3\xe4aYQ\xcc\xd2'3\xbbo\
\xdf)\x13\x0b\xbb\x9c\xfb\xfcw\xd6\xd5;I\x0b\x9d\x8a\xd7\xc6,\xbf\xadr\xab8\
\xb9\xe4\xe5\xcfO1-\x8ai\x0f/\x05\xf2?\t9\xf6R\xf4IH\xe4l\xc1#\xfe\xa6\x0fn\
\x1d:Q<\xe7\xb5\x83\xcc\x92\xeaO\xfb\x8c\xbexj\xf2\x16+\xc8>\xbb|\xbb\xcd&\
\xf3\xbd\xbc\xb1\xee\xd1S>\xba\xda,\xc0D\xc2\xe0\xe9\xea\xe7\xb2\xce)\xa1\t\
\x00ZR\x1c#" )

def get14Bitmap():
    return BitmapFromImage(get14Image())

def get14Image():
    stream = cStringIO.StringIO(get14Data())
    return ImageFromStream(stream)

index.append('14')
catalog['14'] = ImageClass()
catalog['14'].getData = get14Data
catalog['14'].getImage = get14Image
catalog['14'].getBitmap = get14Bitmap


#----------------------------------------------------------------------
def get18Data():
    return zlib.decompress(
'x\xda\x01v\x02\x89\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02.IDATx\x9c\xed\\\xdb\xae\xc3 \x0cK\xa6\xfd\xff/s\
\x1ez:A\x0b#\x85$\xadY\xfc\xd6\xadr\xb1\x9c\x04\xc4\x8dSJD\xc4\xcc\xb4\x0469\
o"b\xe6\xeda\x01lZ\x98v}\xcb\x80\x99_w\xb7\xc1\x04\xef\xe2\xa9\x9a]\x80N\xfe\
\x82W\x1b\x00\xcd9\xe0w\xbc\xca\xb3\x0b\xd3\xb7\x9eW\x98\xbds\xe9\xd5\xc1\
\x99\x96\xa4\xaa\x99\xc3\x0e\xeb\xb2\x11\xd1H^\x1d\xa4n\x8f\xd5\x1f\xfd\xd9v\
\x94\xaa\x98;\x14\xc3\xcdu`\xcb\xa0Q\x03usO\x83\xadW\x031Qzu\xceK\xcc\xca~\
\xf2\nS\xc6\x01\x17\xf3J\xaeY\xf2\xa6.[\x865GL\xb5\xca\xfe\xe94\xaa\x85\xde\
\xdf\x84\xa9^X2\x92\x90|\xe6j#t\xd9\x88\xa8\x19\x81\xdd\xe2\xde\xfa\xd8X\xb1\
\xd1e\x9b\xca+\xddn@\x95m\xaeZ\xe4\x1f\x9e\xef\x12\xf4\xd82Uca\xb0\xfd\xab\
\xd5\xcb)\xb1i\x8c-t;n\r\xb6S\x04\xea\x06\xd5M\xa8\xe5\x95nP\xdd\x81F\xb5@\
\x96D\xbf1bZ\x05\xa1\n\x07\xa1\n\x07\xa1\n\x07\xa1\n\x07\xa1\n\x07\xb5\x19i-\
\x18,\xe1\x08a\xe6\x95\xcd\x12\x8e\x106\xaa\xcc\x96p\x84p\xcc+\xc7\xa5\x965\
\xabE\xa8\xc2\x81\x8d*\xb3%\x1c!\xc2\xabK\xf0\x9f\x1e\xcd`\xe9\x95\xc1\x12\
\x8e\x10\xc6\x11\xa8\xbd\x84#\x84}^\xdd\xb1/\xc0\xa5Z\xb8\xcf\xdd{\xd5@\xdf\
\xb9{\xc7\xca\xee8w\x1f\xfd\x15\x0eB\x15\x0eB\x15\x0eB\x15\x0eB\x15\x0eB\xd5\
\x03\xd1\x98cDVU\x9d\xe5&"`U\xb9\x98\x930\xcc\xb3\x07\xe7w\xca_\xa6U\xb5\xc3\
\xc0\x8aM\xb0?xN\xd5\xd70\xb8\x91mBU/\x0cnd\x1bU%\xdf&n\xca\xd6\x985\x18R\
\xa5uFk\x8cM0\xc7x\xfd\xc4\xba\xb0\xd1BN]\xb6\x7f\xcaEO\xac_T\x05r\x02\xd0rg\
\x82)\x0e:\xcb\x10\xc5\x8c\xc0^7\x00\xeb\x155v\xa6\x10\x91\x8eW\x00g\x0f\xb4\
>\xe9y\xf8,\xa5\xe9\xbc:|\xa0\xba\xd81\xdc\xdcI\xb6\x1d\x98\xf7\xc6|\xbd3\
\x05\xb6\x17\xee\xd9\x00[\x03sa&5\xf0y\xc0\xf4\xaa7\x80\n\xaf\x9e\x83^\xb5X\
\xd3\xabWJi\x99\x0b\xe9\xe8s{\xdb\x927\xed\xfd\x01\x14s\xdd\xc2+\xd1K\xba\
\x00\x00\x00\x00IEND\xaeB`\x82kV U' )

def get18Bitmap():
    return BitmapFromImage(get18Image())

def get18Image():
    stream = cStringIO.StringIO(get18Data())
    return ImageFromStream(stream)

index.append('18')
catalog['18'] = ImageClass()
catalog['18'].getData = get18Data
catalog['18'].getImage = get18Image
catalog['18'].getBitmap = get18Bitmap


#----------------------------------------------------------------------
def get22Data():
    return zlib.decompress(
'x\xda\x01[\x02\xa4\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02\x13IDATx\x9c\xed\x9c\xdb\x8e\xc3 \x0cD\xed\xaa\xff\
\xff\xcb\xf4!M\xc45\xdc\x0c\xe9\xb8\x1e\xed\xc36[\r\x1c\x19\x0c\x8b\x93\xb0s\
\x8e\x88\x98\x99T\xe8\xc0y\x13\x113\x1f\x1f\x14\xe8`a:\xf9\xd4\x88\x99_O\xf7\
a\x89\xde\x99k\xfe\x1c\xc3\x0cc\x12+\x15i#\x8c\xd5\x85\x84\x19\xa2K\xb9y\x05\
\x8eD\x7f3\xaf"aN\xb3\\\xac\xae\xf8\x94\x90\xb2\xc1\x1c\x8e\xb0\xac\x1b\x11\
\xd5cu\xdf\x89\xebc\xf6\xe2~\xb7S\x9dT\xc3\xdd\xdd\xe0\xe6Ibo!;\xf7$\xdcj9\
\x10Sa\xac\xd2y\x89\x99\xd9\x93XabD\xea\x9cW\xed\xcc-\xdf\x94u\xf3\xa4\xf3?\
\x91\x90\x8a\xf9\xfb\x13\xfd\xeek\x7f\x10\xa6V\xe1\x96\x9dDK3\xbd\x9d\x90u#\
\xa2\xe2\x08\xac&\xf7Rcc\xc9F\xd6mj^\xc9.\x03\xa2ns\xd9\xc2ox~I\x90s\xf3\xa8\
\xc6\x86\xc1\xf1W\xa9UN\xc8Mbo!\xbbpK\xb8%#PvP=\xa4\xf2\xb9\x05,\x12\x15\xb3\
\x052\x12\xfd\xc7\x8eI\x8b\x8c\nGF\x85#\xa3\xc2\x91Q\xe1\xc8\xa8p\x94;\x91\
\xae\xca*=[\xddNY\xa5G\xa8\xc9\rn:\xb3\x85Q\xe1\xc8*=8\xea\xa7\x02\xab\xf4\
\xb4\x0b\xb5\xd23\xdc\x15\xab\xf4\xacsS_\xe9\x99\xe9\xcaOWzf\xba"\xa5%\x95\
\x1e\x152*\x1c\x19\x15\x8e\x8c\nGF\x85#\xa3\xc2\x118U\xe1\xf0\x10\x99*{|MD\
\xc0T>L\x02\x86y"\x9d~\'\xbc2MU\x1e\x06\xab\xdc\x1a\xee\x0f\x9e\xa3\xba\x1d\
\x06\x0f\xbaMP\xd5\x86\xc1\x83n\xa3T\xed\xb7\x89/u+\x1c\x07\x0cQ\x8d\x8d{)\
\xb7\x86\xc3\xc3\xfe\'\xd6\x1b;\xdd\xe8)\xeb\xf6\xb5T\xfa\xc4\xba\xce\xba\
\xf0\xd0\x9d\t\xbf\xa0\x883\x1c\xa2\x98#\xb0\xb6\x0c\xc0\xc6\x8a\xee\x9ek\
\xb6\x13\xe9\xae&\xc1\xea\xc2Q\x03\xd9*\xc6pw\'\xddNa\xbe7&\x9b\xe8O\n\xd8U\
\xb8\x16\x06\xd8\x1c\xe8\x83-\xc9\x81\xcf*7\x1aac\xa5po\x11)\x99f\xb0\xb1\
\xbaM\x18*b\x95\xe8\xe5\x9cS\xf3B:\xba\xde\xde\xa6\xf2M{\x1f\xa3=\x01\xc1\
\x06\xc1\x84\xcf\x00\x00\x00\x00IEND\xaeB`\x82{ \x15\xc8' )

def get22Bitmap():
    return BitmapFromImage(get22Image())

def get22Image():
    stream = cStringIO.StringIO(get22Data())
    return ImageFromStream(stream)

index.append('22')
catalog['22'] = ImageClass()
catalog['22'].getData = get22Data
catalog['22'].getImage = get22Image
catalog['22'].getBitmap = get22Bitmap


#----------------------------------------------------------------------
def get26Data():
    return zlib.decompress(
'x\xda\x01\x8f\x02p\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02GIDATx\x9c\xed\\]\x93\x83 \x0c\\n\xfa\xff\xff\xb2\
\xf7@\xdbA\x01\r\xf9@C\xb3\xd3\x87\xb3\xc7,l\x13\x02!j\xda\xb6\r@J\tK \xcby\
\x01H)\xe5\x8b\x05\x90\xb5$|\xf4-\x83\x94\xd2\xdf\xddc0\xc1kw\xd5\x9c]\x0e-\
\xf9\x0b\xb6\xca\xf8\x1a\xc7m`\xdc\xab*\x9d-Kr\xe8~X\xd5\x03;\xaa<\x1b\n\xed\
yu\x89r\xbe5\'\xe1\xd0\xcf\xa1\xcb\x06\x80\xe3\x81\x87\x10\x92/\x9b_\xceg\
\xfb\xa0\xa5\xea\xc4\xfd\xd8\xc3e\xb7\x19m\t@\'Z\xe8.\x00\x1al?\x15\x03\x9d\
\xe3to\xe1\x16\x83\xb6\xa2\x0b\xa6\xb4\xd4e+\xb0\xa6\x07\xeeU\xa5\xf4\xfe\
\x1c\xfe.1\xdf\x08\xa2U\xb8\x17RG\x85\x8d\x0eB\x97\r\xc0\xc5>\x90\xd1\x19/\
\xd2\xe8\xb2\x89\xe6U\xdd\xa5$x\xaa\xb2\xc9\xa2E\xd9\xb1|=\xd0c+T\xf1\xdc \
\xffWk\x89Sb\xabN\xce\x0e3J\xd2\x81A\x8aA\xeb\xb6>9\xd3r\x03\x9b\x14\x83\x88\
\xd6\xbc\x92\xbb\x81Y\x8aAD\'ZX\xf8\xc6\xc4\x13\xab_\xd81\xad\x82PE\x87Y\x8a\
AD\xd8j\x086)\x06\x11\x96\xb62H1\x880\xf6@\xed\x14\x83\x08\xfby\xa5\x9b\xb0\
\xd00%Z\xe8&,\x04\xcc\x8a\x81\xba\t\xcb\x15&F\xf6\x89\xc7\x8cQ\xe9\xa9\xfb\
\x838q\x9aW\xe9\xa1\x0fB\xd82*=C\x88}\xa0\x1f\x84*D\xa5\xe7V\x8c\xabrV\xe9\
\xa1\xc3k\xa5\x87=\x94\xa8\xf4\xd8\xb1-_\xe9\x91\x0c\xe5a\x95\x1e\x8d\xc8\
\xae\x9b8i\xb0\xc5z\xe5\x07\xa1\xca\x0fB\x95\x1f\x84*?\x08U~\x10\xaa\x1e\x88\
\xce\xe1\xa1gU\xcd\xe3k\x00\x8eU\x95b*a>O\xa4\xeb6\xfbo\xc4\xaa\xfan`\xc5F\
\xb8?X\xa6\xea\xd4\rnd\x13\xa8\xbar\x83\x1b\xd9\xb8\xaa\xe8\xb7\x89\x9b\xb2u\
\x8e\x03X\xaax~\xaf\xc5F8<\x1c\x7fb\x9d8h"\xa7.\xdb\x9br\xd1\'\xd6\xa3.\xfc@\
4\x9f\xcfq\xaf\xaa\x83P\xd5\x83\xfb\x13\xe9G\xd5\x85\xfb\xcf5\x8b+\xa8\xcd*\
\x06{\xb8B\xb6\x0fXwg5\xbba{\x8e.\x1b\x00\xc7\xd1\xe2\xf4\xad\x0enU\x9d\xc2\
\xa7\xaa\x83\xa1\xaa\xb5\x985\xaf\x1e\x82\xfe6\xca\xa7\xad\xae\xe0\xd3VW\x11\
rM[\xfdm\xdb\xb6\xcc\x0b\xe9\xf0}{\xdb\x92o\xda\xfb\x07\x80\xdd\x1b\xb1\xa8\
\x14\xb1\x1e\x00\x00\x00\x00IEND\xaeB`\x82\x9a\xee1\x83' )

def get26Bitmap():
    return BitmapFromImage(get26Image())

def get26Image():
    stream = cStringIO.StringIO(get26Data())
    return ImageFromStream(stream)

index.append('26')
catalog['26'] = ImageClass()
catalog['26'].getData = get26Data
catalog['26'].getImage = get26Image
catalog['26'].getBitmap = get26Bitmap


#----------------------------------------------------------------------
def get30Data():
    return zlib.decompress(
"x\xda\x01\x81\x02~\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x029IDATx\x9c\xed\\\xdb\x96\xc2 \x10\x0b\x1e\xff\xff\
\x97\xd9\x87Z\x97\xb6@\xb9\xa4\xda\x8c\x93\xe3\xc3\xaa{\xc2\xc4\xa13\x10+!\
\xc6\x08 \x84\x00\x13X\xe4<\x01\x84\x10\x96'\x06\xb0h\tX\xf5\x99A\x08\xe1\
\xf1\xed\x18.\xc1s\xff\xc2\xee\x02\xd3L\xe36W\xc7\x9a\xa1YE\x0e\xb9B\x92\x1f\
MI\xd8\xe7\xca\nl\xaa\xda\xce\xc0\x18\x11\xc2f\xe2iV\x8b\xad\xaal\xb58\n\xcb\
\xca\x1e\xfe,\xb8l\x00\xf230\xc6\xd7\xe34\x88\xf7\xd3\xec\x8b-\xe0\xb2\xad\
\xe8\xbc\xae\x86\xc3\xfd\x00[\x02F\xb5\xe06\x00\x06[\xae_\xc9\xb6\xa97\xb6\
\xb9:^K\x16j Te\xec\xd0y]\xb5kn\xf9O.[\x02\x9bk\x8b\xc3\x9a\xfd\xbd\xb6H\xff\
N\xf1\xf9$Lu\xe1R\xe9\xeb\x15\xd6\x1b\x04\x97\r@q\x06\x9e\x16\xf7\xd2`c\xc5\
\x86\xcb6u]q\xdb\x00\x95m\xaeZ\xa4\x03\xcf\xb7\x04\x1e[\xa2jl\x1a,\xef\xb2\
\xba\x1c\x89\x8d\xb1\xb6\xe06n\x06\xdba\x06r'\xd5\x97P\xd8_AX\x12\x8a\xd5BY\
\x12~c\xc5d\x05\xb9]\xe3)$\xdd\x98\xf6 \xe0n\xcc\xd5l\tl\xba16\xab\x85\xab\
\xd2\x81\xbb1:\xe8W%\xe6\xc6\xb4C\xd5\x8d\x19\x0e\xc5\xdd\x98\xeb\xd8\xcc\
\xbb13\xa1\xdc\xda\x8d\x99\t\x85\x85K\xdc\x18\x13pU:\xf0\xfdU%\x08\x960\x12\
\xdb\x9c\xaat\xf8ya<\xb6\tU\xdc\x9b\t\xa9l\xa3\xaa\xda\xbf\x98\xfc<\xdb\xa0\
\xaa\xfa`\xbd\xa1p\xd9\x00\x10\xfc\xc0\xc9P\xb8l+\xbc_\xe1\xa7\\\xce\xfb\xc1\
U\xe9\xc0\xf7W]C\x8a\xb9\x9c\xbb\x01\xb2{\xf2\xe1p'\xd9V\xf8/\x95t\xe0\xaan\
\x88\xc2\x9aCYUy\xe3,\xab\xaa\xbaq\xd6tc\xce6\xce\x82nL\xc3\xc6\xd9\xdd\x98J\
\x10\xf3\xa1\xb8\x1b\xf3\x8f\xc2\xaaH\xd0\x8di\xf8b\xb2\x7f\x1d\xd8\x18t#'\
\x97\xedE\xe9\xeb@@\xc6\x8d\x19\xba\xeb\xf1\x0e\xa8\x9e\x17\xa09\x03\xcf\xda\
\x80l\xaeP;/\xc0\xdd\x98\xae!\xdd\x8d\x19d+\xfd\x9aO\xd8\x8d)\xd7@\xd9.\xbcH\
J\xcf\x0b \xef\xafn\t\x9b\xaa\x94\xfbUy\x19\xa5\x99\xab\xb3\x9b\tesU\xad\xdb\
\x9a\xb9:\xc3#\xc6h\xe6@:\x00\xaf\xd3\xdbL\x9e\xb4\xf7\x07\xd4^(\xe0\x9c\xbd\
.\x8d\x00\x00\x00\x00IEND\xaeB`\x82\xc346." )

def get30Bitmap():
    return BitmapFromImage(get30Image())

def get30Image():
    stream = cStringIO.StringIO(get30Data())
    return ImageFromStream(stream)

index.append('30')
catalog['30'] = ImageClass()
catalog['30'].getData = get30Data
catalog['30'].getImage = get30Image
catalog['30'].getBitmap = get30Bitmap


#----------------------------------------------------------------------
def get34Data():
    return zlib.decompress(
'x\xda\x01\xc4\x02;\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02|IDATx\x9c\xed\\\xcb\x92\x02!\x0c\x0c\x96\xff\xff\
\xcb\xec\x01u\x91\xe1\x11B\x02\xd3H\x97\x87\xd5\xc5@W \t\r\x8e\xf3\xde\x13\
\x91s\x8e\xb6@\xa0\xf3$"\xe7\\x\xb3\x01\x02\x17Go~\xdb\xc09\xf7X=\x06\x13<\
\xd3\x0f\x92\x05\x86\xe9\xc6o_]c\x06f\x14\xb9\xf8\x8a"\xff`R\xa2\xd4W\xbb\
\xe0\xb0\xc2An]5\x97S\xdc \xbb\x08\xbb"\xa7\xae5"J}\xc5\xf9~\xc29\xbc\xcd~\
\xc8\x81\xae\xb57.3\xd0\xfb\xffWs\x10\x15pZ\xeaZ\x8bP^Wf]N\xb0\xf6\x0b\xb5E\
\x02LJ\x94\xf1\x15,\x93\x18\x9d\xf9\x8a\xcf\x99\xd3R\xd7Z\x84=\xb3\xf0\xa5f\
\x0f\xaf\xe4\xef\x18\xf3\x9d0\x94\x85K!\xb5\x97X\xef t\xad\x11Qq\x066\x93F\
\xa93Y\xb0\xd1\xb56\xb4\xae\xae]\x8e\xc4OUkc\xd1"\xeex<%\xe8Y\x8bX\xc9\xa6A\
\xf8\xafV\x96S\xb2\xd6\xaa\xd9mb\x94\xb5\xb5\\\xcd\xae\xda\xc1\x12\xe4\xd6\
\x95\xee\xa4Z\x81B\xb4@\xa6D\xbfQ1\xed\x82\x9c\x1a\xd3\x04\x98\x1a\xd3;\x08B\
Qc\xba\x061\xd8r\x81\x1a\xc3\xc7\xfd\xd4\x98=\xa3\xc5a\x85\x83\xa3\xc6\xe0\
\xa0\x9f\x15\x98\x1a\xc3\x07\xaa\x1a#\x1e\xca=\xd4\x18Q\x1d\xf8\xe9\xb2~\xd4\
\xd0U\xe05\xad\xf5\xc0L\x8d\x11\x14x&j\x8c\x0c\xd9\x8d\xb3\xb8\xc03Qcd`\x0e\
\x82I\xd5D\x8d\xd9\x02\x87\x15\x0el\xf6W#\xb5\xc5-\xf6W\xd9\x90\xbd\xda\xda\
\x18\xab\xb8{A\x0e\xad\xe4\x831b\x03\xac\x9a\x97\t\xbb\n<\xd5\xab\x89RV\xcc\
\x83If\x81\xc7?\xe6\xe4A\xc4\xaa\xdeY\x93XW!""6\xac\x07r\xda\xf0\xcbEq\x8f\
\xdf\x98\x95\xaf\xe6\x9e\xb3LT9GR\xd3\x02\x95\xf3~8\xacp0q\x7f5\xd1\xdaQ9\
\xb3\x1ddC\xb6x\xb8\x83\xd6\xde8\xbfT\xc2\xc1auC\x14j\x0edV\xe5\x8d3,\xab\
\xea\xc6\x19\xf3\xb4\xbb\xb5q\x06Tc\x18\x1bg35f\xa95K5f\x9d5c5\xc6\xdaZ\xa1*\
\xb2Wc\xd4\xad1t\xab\xfe:P\xf7\xc0\xc6\xe0\xf8\xe7\xd4\x81\x01 w\xce\x06N\
\xbb\x97\xa3|3\x12v\x06V\xbd\x87\xe9\xab\x0f%\xcd\xc8\x9e`\x95\x1aSn\x89\xac\
\xc6|~\xf7\xa6P\xb3\xdfS\x8d\xf9&&ZW\xd9n\xc4\xf3Pl-{\x8b\x88\x88\x80c`\x15\
\x87\x15\x0e0\xf3U@9\x11c\xfa\xaau\xd6\x0c\xeb\xabj\x90\xc4\xf4U\x0b\x0f\xef\
\xfd6\x0f\xa4#\xa2\xd7\xd3\xdb\xb6|\xd2\xde\x1f\t|I\xcf;\x90\xeb\xad\x00\x00\
\x00\x00IEND\xaeB`\x82\x18\x9dJ\xaf' )

def get34Bitmap():
    return BitmapFromImage(get34Image())

def get34Image():
    stream = cStringIO.StringIO(get34Data())
    return ImageFromStream(stream)

index.append('34')
catalog['34'] = ImageClass()
catalog['34'].getData = get34Data
catalog['34'].getImage = get34Image
catalog['34'].getBitmap = get34Bitmap


#----------------------------------------------------------------------
def get02Data():
    return zlib.decompress(
"x\xda\x01\x08\x02\xf7\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\
\x00\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\
\x08\xdb\xe1O\xe0\x00\x00\x01\xc0IDATx\x9c\xed\x9c\xc1\x8e\x830\x0c\x05\xed\
\xaa\xff\xff\xcb\xd9C\x04JX\x07R\xa9N\x19\xe39\xedrb\xf4\xc8+u(ZJ\x11\x11U\
\x95\x10T\x9d\xb7\x88\xa8j\xfd'\x00\xd5Ee\xf3\x0b\x83\xaa\xbe~}\x0e.\x8c\xad\
\xc8+\xedQY\xd5\xa0\xb0q='\xab\x1aQ-Ff\\\x0f\xc9\xaa\r\n\x1b\xd7\xdb>\x0c4i\
\xe9\xb3\x1a\xc9\xd0$\xad\xac\x0e7P4%\xe9\xb2\xda\xcf\xbe\xd50\x0f\xde\x9e\
\x98\x1d\xd8\\\x81\xe6\x9d;\xf3v>fV1\xad\xfa\x0e\xdc+\xa1\x94\xeeo\x1aV\x07\
\x1e@\xb5_\xe5\xf4\x9b\x08\x96\x98\xeb*\xbc\xd5\xa8\x15\xd8m!\x96\x00PI\x8c+\
\xb0\xd5`*\x89\xbd\xae\xda\xaf\x8cL\x06mAV\x92\x07t` \xd2\x8aCZqH+\x0ei\xc5!\
\xad8\x0c\xf6D\xbeE;\xff\xd8\xef\x98\xcd\x83_\xc53\xab\xc3H\xc7\xdck\xf6\x19\
\xfb\xb8Y\xcd\x9f\xae\x83\xd8\xdau\xb5j \x17\xb3-\xd2\x8a\x83\x9b\xd5|e;\x94\
{f\xf5)3!\xf0>\x85\xe5\xea\xa4\xdd\xe6s\xfeW\xe0/\xc6\xf7K\xd6\xd5\xf2\xf1\
\xfd\xaa\xb6X;\xbe_\xd8\x81\x0b\xc7\xf7k\x9b}\xd5\xf8>?\xaf8\xa4\x15\x87\xb4\
\xe2\x90V\x1c\xd2\x8aCZ\xdd\x90\xc1\x80\x91l5\xfe9\x15\xd6\xca|\xe8~\x83i\
\xf5?\x9f\xfe\x08\xd0j\xe2\xf9`\xa0\xd5\x04iuC\x06#\x03\xa0\xd5\xc4\x80\xd1y\
_\xd8\x89\xab9\x1c0\xab\tbZ\xa1\xae\xc0\xe9\xe7\x1cbf\x85\xb2\xda\xf31\xdb\
\x02\xdf\x81WO8\xa0\xb2\x92\xd9\xdd0fV2h\x8b\rZV\xd2\xbf\x1d\xa0}k@\x03\xd0j\
\x02\xa6U\x1bW\xde1\xdd\x9e\xd3\xfdX\xac\xd5)d\xab\xf1.3\xd9j\xcc\xab\x94\
\x12\xe6\x85t\xb2\xbf\xbd-\xe4\x9b\xf6\xfe\x00n4\x89\xb8\x97\xed_m\x00\x00\
\x00\x00IEND\xaeB`\x82\xb5\x9e\xf5\x86" )

def get02Bitmap():
    return BitmapFromImage(get02Image())

def get02Image():
    stream = cStringIO.StringIO(get02Data())
    return ImageFromStream(stream)

index.append('02')
catalog['02'] = ImageClass()
catalog['02'].getData = get02Data
catalog['02'].getImage = get02Image
catalog['02'].getBitmap = get02Bitmap


#----------------------------------------------------------------------
def get42Data():
    return zlib.decompress(
'x\xda\x01\xdc\x06#\xf9\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x06\x94IDATx\x9c\xed[\xed\x96\xdc \x08\x85=}\xffW\xb6?\
T\xbc \x1a0\x99\xee\xcet9\xa7\xd9L\xc6(\x17\x90/\xa7\\J!"f\xa6\x8f\xa0\n\xe7\
\x0f\x111s\xfd\xf0\x01T\xb10u|\x1fC\xcc\xfc\xf5\xdd<\xbc\x84\xfe8\xcfp\x8f\
\xbd\xa7\x1a?SW\x1e*\xd1\xcf{*\x8a\xfe\']\xbd?\xfd\xa2z\x1f\xf2<\xfbD?*\x9f\
\x8a\xe4\x0c\x80\xaa\xb2\xbexg3\x173\x97>h\xc4\xbaz/O\xcc\xc7\xfe\x84\x93\
\x99MP\xbe!]\x11\xe4\x8a2\xafpSJi\xc0\x0c\xdf\x1b2\x90\xc6+\x85\x04#\xb7\x7f\
m|\x86\xa6}\xc5\xec\xb2U:\x9e\xcaG\xe7J\x16-,\xaf\x97\xa2\x98p?\xe2\xcbj9n@\
\x10\x92\x1dsM\xa0+#\xe6+\xf1T\xde\x1c\xfb\xe157\xfd#\xb7\x19\\\xc5r\x95\xa1\
3mXc\xda\x02\xef%\x13\x8f\xb9\x94\xdb\xce)\xea\xd9\x9b]0\xb7\x02f\xb8\x00\
\xb5\xcd\xaaX\xbc\xab"J:\x89,\x01\xaa\xba\xa3\xc4\xac\xf5\x06\xab\xbc\x94\
\xce\x8b\x00KQ\x15\xca=\x86C\xd4Q\x8d\xc5\x18\xae;c0\xc0\x98\x19\xbd\xb7\xbe\
\x16Q\xf2<M\x98\xd5\x84n=\x0b\\ \xd1p\x1b\x8c(G\xd6\xf0\xa4,\xa0\x18\xbb%\
\x03*\xbe\xaf\x98\xe5JIH3\x19\xdf\xfe8\t\xaa\x15\x8f\x05\xffT\x91\x0b\xa4j]g\
\x0b\xd7yv+#\x0f\xc9E:\xaa\x0bP\xcf\x90x\x0bf\xad\xab\xbdh\xf2<\xac\xa3\xf0\
\xd5b)EMy\xd6\xe49V\xa9\xd6\x91-LQ\x18\xb3\xcf5\x7f\x08)\xb2CB\xf8\x93b\xdd\
\xd0\x94\xdd\x8aK^.\xad\xbeB\xb7\x11\xd9\xff\x17"\xf0\xc4z\xd0\x84\xddvc\xae\
\x08\xdd\x06r\xb5I\xdc\xc5\xc5/\tR\x92\x16\xe5\xf2\xe1;Z\x89lh\xa5\xda\x86\
\x90\xfc\xca\xcdp\xa9\xa0\xc2\xbdD\xb7T\x1cx\x00\x15V\x86H\r\x12|fx\x85\xb48\
\\3\x93\xca-[\\\xdeB%\xb1\x0b\xb7\xd6\x009\x8f\'5l%\x0e\xba\xddSx\xc6\x02\
\xcdG\xdcl+\t\xcf\xe5%|\xc5)\x07;\xd39\xaaV\x1a\x13\x96\xebj\x80-\xde\xe1y\
\x8bY\xec\x8c1\xa6()H\xca\x13\x9e\xa0R\xe59\x111\x17X\xde\xc5\xe6\x12X`\xa1\
\xc9\xcb\xe9\x86By\xa1\x0f\xc4\x95*G\xd0e\xe0\xba>\xa4\x11\x9by\xa8\x8f)s\
\xa7\xa4\xaaE\xea\x17\xca\xdba\x0e\x95\xe2\xb3Jq\x81\x8d\xb6\x01F\xc6\xa0hp\
\t\x04vp\xc6\x1b\xee\x9c\xc1\xb5\xa0\xe7Zc+\xeb*r\x83\xa7M\xa8\xab\x9e8\x9e\
\xc1\xed\xe5.t\xd3"d\x02\xbf3\x8c\xba\x1c\x955\x9e\xb1\xa4|\xab5\x16\xe16\
\xbb\xaf\xc8\xc0\xbb\xd4\x9b\x89\xa1\x12U7x\xe4\xf5\xe3\xdf\x17$N\x0f\x0c\
\xa4\x16F\xbb\xc9\xa9\\\xb0\xb6n\x10\x98xg\xe1Xv\x17N\xca\xccM\n\xf2\xecd_E-\
P\xeeUN\xcfQC*\xbayY\xa6a4\xf43\x9e!cs\'|\xc3m\xd4\x02\x95\tiH{\x9b,"\xfe5$3\
\x8fa1\x1b\xac(\xdb\x8d\xe9|:\x90\x88\x86M\xd6\x17\xe4\xa9\x98"\x19H\xdd\xe4\
V\xa9\x93\xbc\x9d\xad\xafr\xba\x1aV\xdea\xb8B\x1c\x01@k\xcc@\x82&\xdc\xbc\
\xdc\x18u\xa0\xab\xdcI\x0f\xe6/\xb2\xb0+\xc8\xc6G\x07\x86.\xb1=\xbf|\x17\x06\
\xbc0c\x12\xb1\xcd\xac\xb8%`\xc3\xa0\x8f\xde\xe4\x08\x8f\xb7\xef\xce\x8b\xc6\
\xf9\xa4\x83sa\x10\x9eyn\x8d\xab\x1ejq\x97\xf48y\x80\x08\x86I\xe3\xa2\xa0>\
\xd9W9T\xc1\\SR8\x82z\xb6\xf4\xc0\x85[4\x18T^\xae\xabo\xa4\xb8\xbe\x929{\xcc\
\x1ePKfc\x18\x1dFV\x84\xf2t\x91VN\x94\xae\xaf\xd6\x0e\xc3\xb22\x1c\x83\xae\
\xd8\xe5!2\xed:\xf7!\x0b\xcah\xea)]\xb9\xda+\xf0\x9d\xcdw0!\xbc\xd2\xbc@\x8a\
o\xae\x07t\xb5-\x0f;4\x0cV4\xe2\xf7\xe6\xdd\xd1\xccIB\xa2\xfb\xba\xf2\x9a^S\
\x9a\xdby\xe7)\xe1 \x9d\xa1\xe3$t\n\x89\x9e\xf5\xec\xb5\x1c\x99\xeb\x8b\x91\
\x01J\xd9Ri\x94\xbd\xa6\xcd\xd4\xc7\x1fA\xa2\xa7\xf6\x95j\xfd]U"Fc$\x85&\xfa\
\x1b\xb2\x90V}8\x97\xa2\xba\xc2T@u\xce\xba~V%\xe0\x80T\n\x1b\x8d-\n\xcd\x0e\
\xcbB\x8aSBW\x18\x7f\x84sW?\xa4kx\x06%K9<\xf2zy\xdd\xd3\x9b\xa8(\x05,\xdd\
\xe5T!u\x8bG \x91Q/>\xaf\xc3\xd6\xcd\x8fy\xbfE(\xd5\xb7\x98\\\x85\xd7r\x10<\
\xa5\r)e\xba\xcas\xc1yi\x93/\xf7\xec*C\xedl\x8d10\x9a\xa4\xcf\xec]\x1bB\xf0\
\xfb\xb4\xd5[8a:\xeaH\x0b0\x93\xcb!\x1e\xee\x82\xdf\xec\x07\xee\x16\xb6\xc7\
\x96w\xec\xc9x\x85\x9e]\xf5\xdca\x047\xcc\xbbnD\x1f\xdb[\x1d\xbd\xb246)\xce\
\xe9U}\x8b\xb6\xd8\xa22\x1f8\xf5I\xf1*\xc8L\xa2h\x93\x1b\x9b\xcc\x82\x11J{v\
\xac\xfcH\xdf#\xbb\n\xdb4\xd5\n\xb38\xf5c<\x95\x0eO\xe56=G\xb3\xdb\x99\x95c\
\xc4\x1b\x19i\xc2\xd1A\x8ad\xe8\x10\xd5F\x96\x187\xd9\xeb\xbf\xa2\xdbDH\x02\
\xb2\xac~\xfb\x1a\xa6\\\xbcj!h\x91\xe0\xd6,\xbc\xe5P\xde\xcf"\x9b\xdb\xf4\
\xf2t\xd6\xe7\xdf7)\x99\xb3\xc3u\xb0\x03T:\xd1Z\x9f\x1b%d3\xa3\x15%P\x89\xa4\
\x87\xab\xc5\xa8\xba \x96@\xac\xa6B\x13u\xb3\xbe08o\xf5\x93<\xd0\x99n-d\xb7%\
:\x8f\xd5\xd8\x86\x83]M\xa2x\x98V?\xed\x9c\xcd\x12\nh,\xd8H\x94W\xa4h\xbe\
\xe6A\xcf|\xe4\x03W\xcc\x81\xcct\r\x96\x0eA\xae>/x\x80\xd5\xf3\xa8\xf6\xe2\
\x86\xa9\xcbt\xf3\x18\xadx\xe8ei\xd2\x02m\x01\xb5\\\xf2\xa0\xe5?&\xd0\xbf\
\xeb\x15\xd35I\xc8r\xed\x97v\xa4\xef\x00#\xed\t\xb3g\x08\x19T\x11E\xd5qz\x94\
\x94\x9bq\x90\n\x12\\\x1d\xf2\xa0\xa6t\x15\x17\xbc\x1d\x89\xf5\xd8\x1c\xac\
\xe6\xdc\n\x12w\x8f\xc6H\r\xf9\xdc[\xe4\xe9\xcc[H68\xba3ns\x81\xa0\xcf\xd6)\
\xe4s[\xae\x99\xda$G\x9bj\x0eV\xa2CiNE\xb8\xbd\xad\xab+\xb4q5\x9d8\x96\x85\
\xf62\xfb\xca\x11\xd2b\'\xabC\'\xa8\xf5\xe5\xde|t\x96\n\xfcO(\xb6NIn\x93\x9e\
]qP\x00T\x99\xc74H<5\xd1\xe7\x8f\xa5M\xa1z;\x1d\xd88\xe9Z\xb14\xc9%o\x81\xae\
Yk`\x0c\xbf\x12\x0c\xcd\xd9\xfd\xa0i\x1f\xcc\xdd\x91\xe0^\x8dz\x8b\x10s\xff\
\x84l\xd1\xe0\xd5\x04!]=\x9f\xc8\xbd\x98\xde\xe9\x0c?N\xbf\xa8\xde\x87~Q\xfd\
(\x12\xb7\xec\xf9\xe7\xb7E\xb5\xa5\x7f\x91\xb3\xbf\x84\xb6\xc1\xe63u\xf5u\
\xb3\x0e\xffi\xd4J2<b\xfb\x00\xaap\xfe\x02\xd0EV.\n\xff\x06\xc8\x00\x00\x00\
\x00IEND\xaeB`\x828\xf6I\xd6' )

def get42Bitmap():
    return BitmapFromImage(get42Image())

def get42Image():
    stream = cStringIO.StringIO(get42Data())
    return ImageFromStream(stream)

index.append('42')
catalog['42'] = ImageClass()
catalog['42'].getData = get42Data
catalog['42'].getImage = get42Image
catalog['42'].getBitmap = get42Bitmap


#----------------------------------------------------------------------
def get50Data():
    return zlib.decompress(
'x\xda\x01[\x07\xa4\xf8\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x07\x13IDATx\x9c\xdd\\\xdb\x96\xe4*\x08\x85Y\xfd\xff\
\xbf\xccy0\xe2\xe6\x96HRuf\xd2\xac\x9e\xea\xc4\x18e\xcbE\xc0\xeaa\x11!"f\xa6\
_A\x03\xce\x0f\x111\xf3\xb8\xf9\x054\xb00M|\xbf\x86\x98\xf9\xcf\xdf\xe6\xe1+\
\xf4s\xfcF\xbb\x12\xf1\xb7o\xa3\xdf)\xab\x89J\x05\x82\x92\x11y\xa3\xa0(\x97\
\xd5P\xbfw\xe2\x19\x14P\xbd\x1f\x12\xe5\xb2z9$:\xd3\xc07\xd3\x8fo\x18n\x9d\
\x19%\xf6O\xc5S;1C@E9\xb0V\xfc\xc1\xccc\x0c}i\xe7\x1a^/\xa7\xdb\\\xdfb\xbf\
\x1a\x83\xa6C\x0c\xc0\xcc\x84\x0f\x19\xda\x89Dd\xbc\xda\xfa\xd4\x8b\xe7\x11\
\xdcD\xa5\x00p\xaa\x08\x8c-\x14\x9e\x90\x10"\xaf\xd8r\xb07\xb6\xbd\xeaz\x90.\
\xa3\xe6\x10O\xd4>\xd3\xc0\x8a\x92i\x98H\x0c$\xed)""\xcc|\xb6\xec\x13\xdbj\
\x98\x90&\xc8\x9b\xc9\xc4D\xe5^\xde\x1f\xebjEO\x1e\xcb\x860\x18$\xbfO\x1dY\
\xdd\xa2\x13\xbbOD\x0fmN\x1b[\xc0\xc0[\xa0\x0f`\xb0\xdf\xaf\xd1\xb4=\xf3\x99\
r/\xd2\xdb]b&bM\xc5\xb8\xde\xcc\x84\n\x86i.\xbcr3\xcc\xec\xfc\xb5\xa9o\xe6\
\xf6\x06ub\x0b9\xfe]\x91\x90xCGH-]\x92\xc3\xeb\xf4\xde\xfaz~\x85J\xa5\xd7\
\x15\x8b\xae\xfd\xf6\xc6\xa5\xde\xa2\xd2.\xf1w|\xa5\x87\xcf\xb6P\x94\xeac\r\
\xacX\x89\xed\xe7L?\x08\x0b\x14\xcf!O\xf8\xe9\x12h`d\xa8b\xf1\xaa\xfd(_\x81i\
9\xcf\xa1\x18\xf0S\x1f\x1d\x9d\xe1\x87\x9ar\xb3v\xe5\xd2\xfb\x13\xda_\x82\
\xe3\xa1\xd4^;\x817\xfa\xb9\xcf}`\xc1[h\x88vI\xf5\x12D\xdb\xe0IU7\xd3\x9e}\
\xb6,\xac\xc8D6\xc9\xe6\x1b\x91\xe9\xf4\x9a\xac\x8a&\xea\x1al\x89!D\xdc\xe1\
\xeb\xb1g\xb7!\xf6\xda\xb0W\x9c\x9a\xd8L6\xcc\xea?J\xca\xcb\xa2\xc6\xd3N\xac\
\xf3(\x0e\x8c,j`\x12\xa3R\xb7/\xbbMY\xfb+0\xc2Xq\xfa\x8fM\xba\x89j\xf1\x94\
\xa9\x876V\x11wt}\xb8S\xebP\x02\xe2jQ[\x035\x82NyU\x0e\xc4\x8a\xabPB\x9e\xbe\
\xc9\xf4qY\xd9\x8d-\xb0\x81j\x19O\xe6\xbb\x0c\x86\xc1\r\xbc\xe5\xb2@m\xc1\
\xd7\xd7#2\xee\xe2F\x85r\x17\xd5\xe0C\xe4\x10\xc2R!2-\x94\xeb\xdb\xf2\x94:\
\x8er\x8c\x91\xa1Bb\xf6\xde<\xad\xdb<E%\x02^\xa9\xc8\xbd\x8d3\x18-\xc0P\xb5\
\xe4^\xec\x16\x8d\x04\xa1\xed\xd0\xb6\x06\xf2\xf1\xb1lB\xb5\x11\xac(\x8aK\
\x81Q\xa1E\x18U\x8d\xb53\x19\x1e\xdf9\xc3\xe8\xd8\x95\xe3\xc6\xc5uaw\xf2\xfd\
\x13)\x05_\xc2~\x0b\xe6\xef\xda\x95\x8b\x90\xe6\xe7:\x87\x85[\xca\xc4\xe5\
\x07\xcc\x94Y!\xe1\x8a\xa8\xff\xf9\x96]\xc9\x1cZU1\x02#\x88\xf7 8\xf0\x90b\
\x14B\x15$\n\xadW\xd4\xb3+\xad\xe0\xe9\xf4\x9a&h\x98Cv\xb3\xaa\x98\xc1\xbd{\
\xb8>\xeb\x8ft\xb6\xe3\xd7\xe3\xe8\xb6"t\xc7*\xb4\xa0H\xe9\x86[\xd4\xb6s\xf9\
\xd8\xd9\xda\xeaG\rT\x16\x92\x86e"\x06\x18\xc5\xfd\xeaV\x19tI\x89\x97\x02\
\xef{\xf6\x9bq`,\xf5\xfa2\xd0v\x8a\x17#\x95\'R\x1at;\xbaU\x9e\x8a\x1eVd.\xb4\
\xe3(R}O\x7f\xb1q3\xad\xc2\xccgduB\x8c\x0b`Y\x8b\xd9\xd7\x11\x01\xb2\x97R\
\xb7\xd6\x94Gn)gbM\x8b\xf6t=U0.\x1ea\x87\x08IN\x85\x8c\xdc6d\xa5\xf1\xe5\xa5\
\xedb\x10\x94\x85\xe7\xa6\xcfzk<%"Y\xa6\xe5 m\xd2.*\x99\xc1K\xd0\xa3d\x87\
\x8d\xa4\x9e\xd3%T3\xf67\x13UC\xed\x03k\xc4\x81\x18\xa7\x12\x1dAg\xa5\x0eUV\
\xb2\xf7\xd4\x14)4\x9a\xd9\xa7]Y\xb9\xa0\xd3%\x08n\'\x8d;\xf2!\xa2j\xf0\x82e\
\x9d\xe5(\xc6l\xf2\xda\xd5@7Y\xc4\x83\xb4j\x0f^c%\xd6\x06\xfdts\\P\xda\x86\'\
l\xf8@3\x1f!J\xa2l!\xc5\x9d\x0b_\x1d\xf6p\xf8>\xc3\x98\xc5\xf9\xc3\x0f\xfb@J\
\x9d;\'\x90\xf2\x89Om)\xebKT+\xed95P\xa1\x94V>\x94\xa9\x9f\tp\xebGBTy\x9bD#:\
\xd4\x8e-\x8c\x94\xcec\xd3\x13\n\x05j\x1d\xdc]|WVj\xbe\xe7R:q\x1e\x86\xb2\
\x8a<b\x8b\xdebo\xdc\x83\x9a\xb1\x05\x95RB<\xb6\xc8\xec\x07!\x88\x95\xe6\x1e\
\xc8\xd8\xb8\xba\xddU\xc5\xf6.\x1c!a\x1a\x8b%\xf22\x9a\x0f\x99\xb2@\xa5@oiF3\
k\xbemu\xecT\xa4\xd5\x01\x86\xb6("\xb2\x11\xea\xd12\x15X\x9bE\x84B1\x07\xa1\
\x8e\xb7\x86X?_\x0f\xe49U\n\t\x82\xd1U0\xca\xdd\xbb\x19\x93) \xc1[\xdb\xb9\
\xe19Zu\xf6\x83W\x9f\xff\xd1\x82U\x95\xd1\xf5u%\x14\x17"Y\x8d\x94\xf7\xdf\
\xa1\xde\x99\xc8\x11t\xce\xa0N!\xe1\x96\x9f\x86BX\xa9\x8c\xe2\xd2\x12"[\xabS\
<\xeb\xea\xb3\xa8\xcazwH\x0fb\xf4\xa0\x90\xd6\x19B`2=dYC\xc9\xd7\xec\xcaeA\
\x873`\x7f*\x87\xea\xc7\x8ce\xe7<Bu\xa7\x8c\x8c\xd6\xa5eF6\xea\xf01Td\xb5h6\
\x19H\xe1H\xdb?b\x06\xd7?W\x87\x82\xca)\xe1\xe9\xd1>\xa4\x1e*\xe5u]\xa3\xf6\
\x1bq\xd1\xb2\x05,\xb8\x9b\xddY"0;Qy\xa8yI\x9d\xe8v"!\x8b\'=\x92C\xaf\xedx5\
\xf8\xed\xae@0\xc5\r0J\x8d\xacqLE||=\x0b\x93%s\xae\x01\xc7"61[\\"6\xf6)\xe9}\
0J\xfb\x15i\x13\x07atfO{\x13\x9e\x9c\x12\xc6\xfc\xdf\x0b\xc7g\x8em\xda\xae[\
\xa0\xad\x00\xe92\x1b\xaf\x15N\xb1b\x16\\\x16dF\xcf}`Y\xcf^t\x8b\x81L\x0cjV\
\xcfX\xd9\x9cD\xd6\xc1x\'a|\xd1\xc6\xf6\xa4K`i\x7f\x17\x96\n\x92\x13Q\x11[\
\xf0e\x05&\xdd\xcbv\xfb\xdb\x9e\x1dYA\x9a\xa0QLj3I\x01=(\xa4\xf31%\x80\xfdvh\
\xe9\xefW\xf0CY\xc2w\x87.d\xb2\xd1b\xdb\xdb\xa8\xac\x85\x0cW\xff\x00\x0f\xd5\
,b\x8f\xb0E\x9f\x8f\xf5\xf4\xdbY\xe9-\xb6;1>]\x82=\xea}\x8fiH\xa6\xc5\x99\
\xdb\xac\xedh\xb2\x8eb\xaf\x86){e\x1b\xc0\x1dY\xb9\x90\xcfm\xa9\xb1g\xbc\x05\
?\xb1\xbf@\x10]\xad\xe0_\x83\x02\x13z\xb7\xaa\x9c\xa5\xd7\xc6\x0b\xfc\xfc"\
\xf9\xd3!\xb3|\xdd\x8a\xf4*\xfc\xc3\x81\x85\t\xa6\x94\xf8\xff\xb2\xa2Hm\r<\
\xd17\x17P\x9d\xfcy\xd5\x05\xd6\xcb\xf3\x0f|*\xc9\xff\x1ap\xfb\xb4\xdb\xa4\
\x1e\xd6\rL1\xd6q\x9cf\xbb\x19\x00k*\x96\xddM\xba\xff\x1diS\xd0\x1c\xd5\x88\
\xc9\x06\xc3\x9f^V\xd7\xa4ka\xd8\x95\x05\nW\xc5A\xc2\xe3\xbax\xfb\xfc\x9b\
\xdf\nI\xc4L\xb1\xf9\xb9\x80\xc9\xfc\xa6\xe8b\x1d\xda#\xb9\x85t\\\xd1F\xa2\
\xf6\xb7\x8c>%\xc3-\x96\xafh%\x81[v\xf5\x91\xfc\xf4+$\xf9\xb7\xf7\xdf\xff\
\xbfvd+\xfe~T\x99u\xbc\x1cU\xe2E\x89\xde\x8d\xaa\x80DoE\xe5<\x04n\x94D\xf4VT\
W\xf4\xf5\xbfX\xff\nU\xa1\xc6\xa4\xdf)\xab?O\x0b)\xff\x18\x1d5\x85\xb3\xcc\
\xe2\x854\xe0\xfc\x07\x8b\xa5Tg[\xbdl\xdf\x00\x00\x00\x00IEND\xaeB`\x82{\x96\
\x99\x90' )

def get50Bitmap():
    return BitmapFromImage(get50Image())

def get50Image():
    stream = cStringIO.StringIO(get50Data())
    return ImageFromStream(stream)

index.append('50')
catalog['50'] = ImageClass()
catalog['50'].getData = get50Data
catalog['50'].getImage = get50Image
catalog['50'].getBitmap = get50Bitmap


#----------------------------------------------------------------------
def get46Data():
    return zlib.decompress(
'x\xda\x01F\x07\xb9\xf8\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x06\xfeIDATx\x9c\xed[\xdb\x92\xe3:\x08\x84\xad\xf9\xff\
_\xe6<HB\xcdE\x0e8\x93\xecIj\xa9\xd9Y\xdb\xb1%Z-P#gXD\x88\x88\x99\xe9+l\xc0\
\xf9!"f\x1e\'_`\x03\x0b\xd3\xc2\xf75\xc6\xcc\x7f\xfe\xb6\x0f/\xb1\x1fs\xe6\
\xa2\xebc9\x04\xaeb\xc2\xf8\xd8\x14\xf2\xe3/(?\x1f\x0b\x89\x0cW_d\xffP}\x8e}\
\'\xaa\x90-2\xfb_\xe9\xa9\x8af(\xa1\xaa\xb45\x90\x8b\xc8\xd4,K\x85\xe9\x88\
\xc8\xfc\x87\x8f\xb4eMq|\xab\xa8*\x9d9H\xa9\xbcd\x9ek\x87\x81\xb4}\x95\x8d\
\x9c\xe7?\xa2\xb6\x1e\x08q\xc5<\x7f\xca\xa6\xe3\xa7`\x96\'\x89+\xc95\xd3\x17\
O \x08\xc9\xdf\xf3\xd8\x00U\xec\xb0<B\xe3F\xe5\xe7\x02\xdb\xb8\xbc\x89J\xdce\
\xf8\x1d\x9e\xac\x99\xe5Jd\xfe\x94\x1b\xc2\x89\x8eSn\x00\xf3a\xc0\xb5\x81z:9\
\x1d2{g\x1e\x8b\xcc\x91u\xb48\xd2\xde\x99F\xcf\xd9\xa2\x00\xccQ\x81\xb3.=&"b\
"!\x91\xd7\x96\xaaV\xb33\x04k-g(Qp\xe5\x08)c\xad\x0e\xac1\x04\x0b\xd5\xee\
\xdb\x06\xeb\x19X\\:\xc6\x94s\xc7\xf8{\xb7\xae\xd9"\xaeb\xb9I\x07T\x1aW\xe5`\
\xddDu\xba\xe4\xd7\xef)\xbcO\x07"\x12\xc3\xf3c\x80=\xa2\x08P\x9d\x9ek\x0f\
\xea\xf0\x18\xfd\xf6\t\x03n\xd3;\xaeZ\xec\xf3\xbaP5A1\xf3i\xfa\xc9\xb2\xa41\
\xbf"\x17\x80\xdd\x9a\xab\xbf\xa3-\x96b\x98,\xb9\xf5w\x0c\x81jE\xfb\xe0%\xb0\
\xbb\xe1\x17\xb4E\xbfEfs\xbbOz\x83U\xd3\x89\x07\xb6\xb1\xddr Z\xc8\x16K\xd2\
\x15\x9f\xe7u\xef\x10\xe3\x8e\x10\x85\x84dR\x00F\x88\xad\xe9@j\x99\xb6\xe8A\
\xda\xcb0\x02\xc3\x96\x90\t\x95\x14i\n\xe9:p\xb2\xfb\x99\xddVJ\xe6\xa2\xfe\
\xa0>\x19\xa7\x17r\xde\xa5~\x8c\xd2\xaeow\xaa\xc65\xcd\x86\x97\x0cU\xc8\x04\
\x16m0\xaa\xc4\xeaD\xd5z\xd9AZ\xe3\x85\x07\r\x02\xdb\xa80\xfa\x17\xb0\t&VL\
\x96Cq9\xef\x01\tLB\xb3\x8c\xecj\x91\x1e\xaa5+&\x1e\n\x8c\xb9\x8c7\xc1\xcc\
\x8b.\x8d\xfbL\xe8j\xb3\xc9\xab\x90\xf4\xb9j\xc4\xd5\xe8I\xabJ<`\x1ek\xb1.\
\xcd\xc2\xac5"\xd3\n0\xf4\x1b\xc6ho\x10\x90\x89\xa8\xb9\xbe\xbbh,\xb9J\x05~]\
\x8bJ\x14\x85,G6\x81\xb9\xeb\x8b^\xbfQ\xc3<\xa8\xde\xeb\x04>{\xf1\xe0\xc9\
\xdb\xfa\xce\xd9\xf1T\xbb\xa49\xd2\t\x92\xd0\xda^\xd0hI.N\xe2p6xj\xe7dUTq\
\xe4\xf4\x94\xce\xa3\xa8\x0e\xc5\xf1vxB/\xbb\xa9\x1b\xab\xd7\x1d\xaeNs\xcc-D\
\xa7H\x98\xc0\xf4\xa9@Q\\\xa3\xba\xfb\xa1\xd5l\x81kQ\xdc2t\x19\x0c\xafD\xa2L\
\xb3Zz\xb2\xa9\xfc\xc54\xf5\xb2\xcc\x8e\xea,\xaaU\xdcvN\xb5\xb9\xbb\xd9\x04\
\x92\x963K+v3^\xb4\x06W\x91\xae\xf5\x91\x19d9`{\xe0+\x93\xfb,\xdd3-Z\x15\x15\
\xaeNx\x9ax,\xf3\x17,D\xd6\xd1\x89\xc2\x12\x956u\xd7\x1a90f?\x17-[@\xc1t\xaa\
\xb5\xaem\x1aH\xb7\x116\xb8\xa2E\x91#\xca{\xe8\xb7\x07u\xa5>\xa8\xef\xa4\x02\
\x16w\xec\x15\xe4#\xbb\xc3U\xd4\x13\xe8\xa1\xe6\r\xe1\xb9Y\xaa\x8f\x8c\xa7\
\xd8\x01\t\x11\xe54\x94h\xcbe`w\xb8\x1a\xce\xed\x05\'U1AR-)H"{\xaf\x93\xa7\
\x82]\xcb145"\x10\xdb\xadg\xf7\x9b\xdaB;\xc8\xf7\x9c\tY\x9bOa;qhh\x15`\x9a\
\xd9#\x86\xfa\x14lk\x0b\xe3J\xb6\xbc\xc8\xcaq\x8c\xf9\xc3\x0e\xca\xc4\xa6x\
\xa0\xb5\xb4w\x86g+\xd6\xaaD<$J\xb2\x16xq\x88=\x821\xd2Z\xe3\xd4 \xad5\xa0\
\xa5.:\xd9\xe2\xfc)\xd4\xf7\xc6\x15\xa2\x1dN\xbb\x1d\x9d\xc3\x07H\xee\xadWW\
\xb0Sc\x06\x86++\xe2\xd9Ar\x02\xfc"aj6t\x8d;H\x14\xc2\xf2\xa1\x95\x15\x93=f[\
#M\x19\n\tM\xb6\xc2\xd8\xa9\xcf#\x8c\x89\x13s\xa0e\xbb\x0e\xa9\x81J\xc6\xd7>\
\x17\x1e\xa7\xd0\xd5I\x9dWxQ=Sx\xa3\x1d\x9c\xaeY\x8f\xfb U\xd5\x17\xd6\xc8\
\x16\x1b\x18\xa6\xf28\x80\x87\xe2W\xcb\x8a(>N\xa6c\xf1*\xae\x9c\x7fG\xb5V\
\x1b\xce\xcd\xf0\x8a\xbd())\x08\xb4\x97pu\xf2\xcf\xee\xf1\x8d\xab;g\xb2+\xc0\
\x04\x1e\xc4G\xe2\x82~\xae}\x1eZ\x0f\x95\x96\xdfqU\x89\x11\x15\x1f\x04\x8fg\
\xf5\xc56\xc0\x08h\xbc\xae}\xae\xed)\xae\xc4\x89\xc0GD9\xdbE\xa1\xbd\xb8\x0e\
\x12\xba\x8a\xd6C\x85\x1b\xdf\xe4\xf2\xc2\xcc\xe8W\xfaC\xcc\x0e\xb6\xffR\x9a\
S\xc91\xa2\xea\\5v\xa4\xed\x0e\xfb^\xac\xf6V\xebBG[\xb9]\xedK\x9eR\xce\xa9<\
\xad\xdb\x8d\xb7\x07\xc6\xad\xa8z\x15\x8fsW\x9d\x8be\xb5\xbb\x93\x02-]m\xd1}\
{\xa0\xa2{\xe7_"\x1fHp\x7fN\x14*C\xa2\xdd\xa0\xb6\xe9\n\x9f\xae\xdd\xc8\x81F\
\xfb,\xc5 ls\xc3\xcer\xfb`z9\x1f\x9f\x99@\xc8\xea)\x05#\xc9k\x8aj`5\xb5\x85N\
9\xde=\xcd\xad\x05\xab\xa1\xb2L\xa0\x85\x960\x13M_\xe7\x1b\x13\x85\xe7V\'\
\x1c\xb8\xba\xab\xbd\x19h\xaa\xd4\xf5\x168\x86P\xf6\xe0\x003_d\xc5|0&\x9d\
\xac6P\x04v!\xd1\x8d\xb7r\xbb8?t\xe4\xdew,\xa7\xe7\xbb\xb9\x145\xd6,\xca\x18\
\xca\xa8\x96\x93t\x8f+w\x00\xce\x99\x88\x82I8Y\n\xfc\x18T\xcc$b\x18\xbb\x07\
\xa9\x8d\x8aB\xfc\x80g\xecN5\xc0\x1c\xa4XG\xba\xa4\xaf\x077\xb2\xdf\xb0\xa7\
\xbfsv\xee\x19_\xfcDH\x02\x16\x12}\xb2\xc1\xd4r\xe09T\xa0\xcf\xb0\x94\x84\
\xcf70\xb2\x90\xf0\x06\x04\x16\x05W\xd1\x01\xb4\'PY\x951\xfe\x8f\xd8.\xde\
\xafa\x1c\x92\xcb\x19w\x1d\x18v\x17U\xe4\xdd\x8a:\xfb\t\x12\x82\xfaU\xdcrw\
\x13R\xb8r\x0b\xd5)\x96\x1e\x01\x0b\xb7s\xf2J\x01\xcb\x99\x13\xcaS,\xaf\xeb}\
T\xd7y\xe9\x0c\x8c\xc22\xedD\xc9o81\xaf7Q\x85\xaa\xea\xba\xc7\xb8\x9a\xbd\
\xc7^\xfbm\xe2^\x8e&3\xfd\xaa\x96Q\xddAU!j\xdc7\xf3\xed\x94W\xda-&=\x8c\xa8\
\xf4\x85\xdd\xd5\xcc\xdc\x1f\t\xfc\xde\xd7[\xda\xa2>\x80\x0c=\r]\xbe\x1f\xb6\
\xd5a\x10\xc4E\xa2L\xddBn\'\xe8w\xfe\xaa\xec\xd0\xef\x12\xe9b\x06$\xecOx5L\
\x95\x14r\xb9\xba\xbd\xf1[\xfaz\x90\x7f\xfbex\xd9\xd4~\x87\xbb\x9fFU\xc8\xcb\
\xccf\x82\xec\r\xb3\xe3\xeeR!\xc5\xe0\xee\x02\xfb\x1d\xd0\x0e\xaa\xa43\x1b\
\xac\xf6\xce\x9d-\xce\x95\x98\xdb3m\x10\xf5\x9b\xda\xc28(\x00J\x0e\xf7\xe4\
\x0e\x90W\xf4\xfekP\r\x7f$\xd9\xd4\xedg\x8b\xb4\xd7\x90\x85\xec\xe6a\xda\x8c\
\xff\x83U\xba[#F\xab\xbfAm+\x83\x8b\'0\xa2\xe2\xe9\xf3VB\xf5[C\xf86\xfb\xce\
\xbf\xc3\xff\x87\xeas\xec;Q\xbdP\x07\xbe\xc3^\xa5\x98\xfe\x96\xc5\xb4\x0cW>\
\x99\xab\xf3z\xf3\xb1\\]\xda\x9f\x8b\x17\x19\x9fhS\x7f\xb9\x17M\x9fn\x03\xce\
\x7fW\xec\x8bG@\x0c\x88\x01\x00\x00\x00\x00IEND\xaeB`\x82W\x18\x8b\xe9' )

def get46Bitmap():
    return BitmapFromImage(get46Image())

def get46Image():
    stream = cStringIO.StringIO(get46Data())
    return ImageFromStream(stream)

index.append('46')
catalog['46'] = ImageClass()
catalog['46'].getData = get46Data
catalog['46'].getImage = get46Image
catalog['46'].getBitmap = get46Bitmap


#----------------------------------------------------------------------
def get53Data():
    return zlib.decompress(
'x\xda\x01\x0c\x05\xf3\xfa\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\
\x00\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\
\x08\xdb\xe1O\xe0\x00\x00\x04\xc4IDATx\x9c\xed\\\xcd\xd2\xdb*\x0c\xd5\xd7\
\xe9B\xef\xff\xb4Zd\xd1\x05 \x0b\x10F\x128\xb1\xd3\xefL\'\x93rm\xac\xc3\xd1\
\x1f\xc4\xbd?\xaf\xd7\x0b\xbe\x0e\x7f>m\xc0%\xf8e\xf5\x1ch\xac\x10\xdfn\xc6f\
\xfc?Z=\x1f_\xcf\xea\xf9\xe1\xc4\xf8\xa9\xaap"F\xf4)kv\xe1\xc7\xd2[\xe0\x9dd\
$\xc3\xa2\xff5\xcf\xb5f\xcb&\x18\x97\xd7\xca\xeaj\xec\xf5\x86\x9a\x15\xcf}\
\xb14\x92\x03\x11 N\xfc\n\x11\t\x00\x88\x8c\xb1 Xq\xaa@L\xcf\x89\xd8{\n\xb1h\
$\x061\xfd5Y\xdc\xd3+\x94\x1c\x0f\xaa\xb5J3&b\xfb\xa0\x92\xe9\xae9\xb8\xb5\
\x9c!\xabd_\xe7\x0b\xe3\xcaB\xa6\xbe~\xb0\x94\xfeU\xee\xe2j\x87P\xc5\x97}>,\
\xfd\xb0\xcc\x83\x94\xc3\x0e\xc0c\x94\xe8-\x92\x11\x9b\n1q|.\xaeQ^h s\xaa\
\x80\xb6\x0f$\xca\x7f\x16l\xa8\x12\x9a\\\xa9S\xf0-\xad\xc2tx\x90\xdd\xae\x9d\
\xddm\xe2S-\xaa\xcc\xab\xf3\xdb3\xeaQI\xccj\xc96VJ\xcd\xe1\x8c\n\x0b.\x9d\
\xc801\x1bjV\xcd\x1a\x9b\xd1Pjc\xc0\x10]M\x92\x80*U\x08b6\x0cv\xf8\x9e\xa5=\
\xeb\x0c\xe4x s\xe4\xec\'\x88\xd9\xd0\xb1\xdaD\xc9\x95\xb2\xd2\xf5i\x1e\xfe\
\x92F\x01\x8f\x9ej-\xae\xcc\xd6L\xfb\xb7Up\xfd\\\x8a+p\xe4\xe2)\xa5C.s\xb5\
\xe0\t\x8f\xde\xefp?G{\xa0uL\x86\xfb\xb1.\x8b&\xc5\xbc\xaa6*y:\x8c\xae\n\x1b\
,\x90*\xf5mN=\x9f/\xba\xfa\xc7|\xa6^\xf1\xf6a\xff)\x00i\xc4l\x88\xb0"\xaa\
\xf6B\xf2S\xbb8J\xb8\xc9~\x9ez5\xd8\x0b\xc3\xc4\t\x131\xee\x8f\x1a\xd3\x17\
\x13#\xef\xa96\xc5\x158\x1a\xdcF\xb1\xd3+\x1dr\r\xb3\xdf\xdb\xe2\x8a\x89\xd5\
\x83+-?\xab\x04\x9dJ+q\xe5\xdc\x145\xc4F\xb2\x8c\xc6\xb9\xe5K\x10\x8e\xd7e\
\xbf\xa5z\xe5_i\x8e1&`\xb9+\x87%@\x153z,\xe1qn\x11\x8c\xab\x10TW\xec\xae!V\
\x06\xaa~|\xac\x8c\xf8NKq\x15\xdd\x96[\x88\x81\x92\x0c\xba\xae\\Si-\xae8\x01\
\x86"\xde\xa4\x18\xf4\xc9`\x12K\xb4g\x7f\xb5\x80\x13b\xa7\xc9@W\x0c\xfbq\x1b\
\xba\xbd\xf0\xf2\xc1\x10im\xe1\xa0\xb0N\x14\xa3~<\xc2\n\x1c\xbb\x06\x1d\x08@\
-1M\xa5\x89b\xb8\xb9^-\xa2$h&v\xda\xfe\xe8\x8a\x95\x16,^\xaf\x0690,\x97\xa89\
\x87bf\x97+\xe9\xa1\x14\xc0^\xb1 +\xf3^x@\xa96:}\x18\\N^\x93\xf7o\xed\xf5\
\x0eC4\x0f\x0c\x0b\xd5e\xb0:\xdc\xa7\x8a!\'\x89p\xf6\xd3X1\x9f\x181%\x83\xe9\
jL\xd3z\xbb\x1cN\xec\xcb\x16\xb3b\xeaM\xebaJqV)\xee\x8e\xcf\x89\x9b\x05\x15\
\x8bQ\x8a\xb0*9\x92\x8eOp\xb4?>\xc5\xa2\xf0\xb1\xc2r\xba\xc4\xbb\xfa\xc9&/\
\xae\x98\xd9\xa0\xe6\x8b\x97\x15S:\x88\x81\xb7\x16\x19\x15\xb3\x1b\xa5\x17!+\
+\xa6\x94\x90\xcfa\xd2\x9c\x9e\x86\xd5\xa0\x98\x87\xd2\xa0\xbaZY\x8d~"\x80\
\xd4@lT\xcc\x85tcg\x9b\xcb\x03\x91?;b[\x14sR\x1a\xc3\xc1\x8a\x8f\xfe\xfaq\
\xbd\x1b\xf0*\x16\x03*\xfb&\xc7\xfb\x16G\xde\x1bx#\x96\xfa\xd5u\x15\xd3\xefQ\
J\x83\x1e\xc8\xc1\xea\xfc\xe4Y\xfe\xa7B/\xb5\xb6Xk\xa2\x11\xdb\r\xc7\xfb\x81\
\x81\xe3\xcb|#\xc8\xce\xa3\xfd\xeez\x95\xa7I\xc5\x95\xef\x89\xf1\xa5\x1ch\
\xb9\xab\x14\x005\xc6\xb2\xf8Z\xc9\xb1>`)\x07\xae\xfc\x90#\xd2I\xed~\xe2\x82\
\x85\xe9\x15\xd8\xdf\xe5\\u\x7f\x91N\x00 \xba1m0\x98\xe4\xad\xefr\x8e\x96\
\xc6\x15Z\xcd\x8c<\x85\x1c\xb6\xb2\xf2\xfd\x04\xecA\x9c\xd2\x18.\xad\xd2\xf9\
J0\x1f^\x82e\x0f,\x99\x98\xa0y\x87*\xcc\xb0,P\xec\xee\xfclu\xd8\xce\n\xd9~*\
\x9dr\t\xfb\xb8s^$\xb9C\xab\xca\x02D\xac\x87\xa4\x80vzu\x86\xdf\x86\xd0[\xfa\
\x1d%\xbe\xa6\xd4$G\xd6^"\xc67\xd7\xb3\xf83\xbbF\t\xf3\x81+w\x0b\xf9A|\xf0y\
\xdc\xb1\xfd\xbd\x0cmU\x9c\xa71\x06J\xfc\xac\x11\xa5\xea\xad\xb2E,\xee\x85\
\xa5M\xcd\x98\x97\x12\xdf%\r\x8bC\xbb\xdf\xccj7\xa5m\x8e\xa8y\xa0\xb9\xb7\
\xb8\x80\xd2\x067\x1c\xa4\x9a\xe0N\xe4\x16\x94\xe4,\xf5t\x91\x13\xe9\xbbP\
\x1a#p"}wJ\xe0\xadWw\xa4\xc4i\'\xb0\xc3\x87;S\xea\xaa\x96c\x87\x7f;J\t\xa5\
\xe3\x96c\xf6\x1cxKJ\x03\xb8~=\x80;R*G\xabr\xcc\xa1\xd5\x1d)\xc9\x88\n\xf5\
\xecVJ\xef\xc6R\x1f\x08\x007\xa44\xc0w\xfe\x8bu\x13\xab\xbb\xa3\x8b\xab\xe7\
\xff\xff-\xb0\xfc\xdc\x18\xa8\xc2\x0f\xc0Wi\xa5\xe1\x97\xd5s\xf0\x159\xb0\
\xc3wj\xf5\xcb\xea9\xf8\x07\xc9\xedn\xc1}S[\xd0\x00\x00\x00\x00IEND\xaeB`\
\x828\xa0t_' )

def get53Bitmap():
    return BitmapFromImage(get53Image())

def get53Image():
    stream = cStringIO.StringIO(get53Data())
    return ImageFromStream(stream)

index.append('53')
catalog['53'] = ImageClass()
catalog['53'].getData = get53Data
catalog['53'].getImage = get53Image
catalog['53'].getBitmap = get53Bitmap


#----------------------------------------------------------------------
def get52Data():
    return zlib.decompress(
'x\xda\x01\xf3\x03\x0c\xfc\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\
\x00\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\
\x08\xdb\xe1O\xe0\x00\x00\x03\xabIDATx\x9c\xed\x9c\xdbr\xeb0\x08E\xd1\x99\
\xfe\xff/\xab\x0f\x9eP\x0cH\xe6&G\xf1\xc9~L-\xc3\x02\t\xb0\x93i\xeb\xbd\xc3\
\xe3\xf4\xef\xdd\x0e,\xd1\x97\xeas\xa4P\xb5\xd6\xee\xf7\xa3V\xffM\xae\x1e\
\xa0\xa7S=\xe08\xa1\x1a\xed\xc2\x07\xd8\x03\xfar\xb30l\x95F\x8b\xc3?\x85\xf7\
\xbaA\xc6\xf8Z\xa9V\xabv;\x9c\xa8\xf0\xd6\xab3C\x19z\xef\xad]\x1c\x04<\xf0\
\xee\\\xd1\x95\x97fbR\xa3\x86\xb6F\xb5*P\xc3N\xb9:V\xdaCb\x94e\x0bP6\xb5,\
\xbb\x02\xbd\xf0\\y\xf7\xf3(\x94\x81(\xf3sU\x92\xa8X\xdf\xa3\xfb\x90\xf9\xe3\
\xf5\xeao\xb6\x98on\xaf\xf0|&c\x14\x03;\xcd\x81\xfd\xa5\x8c\x13\xf4\x00\xc8\
\xf0\x8f\xc4\x96\xd0\xcf)\x98\xd1\x8d\xca\xe9\xf60L\x83\xea\xaa\xc8jn\x0br\
\x95\x91\x8c%VTHl\xe9\x82\\\xb1\x18\xdb\xc5L\xb2\xb8ZN\x17\xbb\x1eD\x96\xb2\
\xb9\xf2\xb6\xe0\xc9\xf5\xac\xf3\xc4\x82Up\xae\xaa\x90\xbc\xb5\x18\xab\x14-W\
\xc5\xb92.^4X\xb1\xfb\x17\xe4\xca^\x8b/\xcd`t\xed\xdd\x02/c\x83RA\xae\x8c\
\xcf\x91\xde>\xeb\xed\x84\x12)\x98\xabQ+d\xb2\xf7\xd9\xcc\xfcU\\\x03\xbd\xb6\
a\xc1\x98\x0f\x85\xb9r\xd9\x03[\x9f\r\x03gr\xa5?\x0bO\xbc\xa4\xbe\xe2|\xc4L&\
\x0b\xe3\xa8T\xd8\xc1\x94\x1ah<\xd6,c\x96+-\xca#A\xf2\\\xa9\x96\x92#?\x8c\
\x91R\xb3\x85k\xb4\x91{O];\xfa\x1cG>4:A\x8a\xe7\xca\xbe\x03\x99\xc7t\xe4\xb1\
\xacB\x17Y\xc9\x99 \xad\xad\x81R\x96@\xe25GZ.\x01*s\xe5\xdd\x81.00\x9c\x9c\
\x92\\)o\xce\xc22\xda\x0e#\xdd7[\xa8\x1e\xab\x7fJf)\x9e\xab\xaaN*=(A\xca\xd6\
\xc0<\x0f\xf5\xa0\n\xe9\xee\x1a\x88\xa2\xe6\xb1\xe2U!ek`8],\xae\xb5H\xf1\\\
\xc9\xfd\x13CB\'\xeeGR\xa8 Q\'\n\x012H\x9c\n\x17\xc7\xc06A\xe2T\x19\xed\x83\
\x14\xa7\xa2\xf5\r\x0b\xcc&H\x10\xf8VN\x965Xv\xa2bH\xe0\xcd\x15-\xd9; a\xadf\
E\xdbAE\x8b5,\xe8E\xb1,5\xad\tY\xa9\x98\xb1\xde;K\xda[\x90\xfa\xa0\xbbZ\xa9T\
c+\xc0\xecHhZ\xae\xf2\xed@\x10\x81\xa9\x05s!M\xe4\xa8\x81#\xdbU`1\x00\xf5\\9\
\xa8\xe6\x1e`I\xbc\x13i\xb4\xd0\x97\xab\xc9\x8d\xe8\x9f\xbcx\x0e\x0e\x9b\xac\
T.\xf3\x01\xbc\x80\xebp\xde~\xf4&\xa9\x1ahY5?u\x90\xfb>\xa5\xbf\xc4>w\xf4\
\xab\x98a\xb4=\xc9O\x06L\xd5}\xbf\xe5\xa4\xe5\x04raB\x8dnr\xebo9G\xa1\t\x1f-\
v\x80Q\x8ej1\xf7,\xac\x15e0\xfe$R\xebGLe;\xf08\x1e\xa3\x92\x1a\xf0)\x13\xa0\
\x82.\x0c\xe7F\xdc\xc4\xb3M\xc0\xbfE9w\xcf\x16\x87d\x98i\x02\xed\xbe\xbey\
\xb6\x98#\xe15\xd8\x8e\xec\x1e$g\x0b\xda\xe5\xf1s\xf7\xdb\x18\x15I\x8e\x0b*\
\xf3\x8a\xb4\xa8\x11t\xbf\xb7\x80+$\xd5\x18=\x8a\x85x\xec\x84\xa3\xdcO\x8dy$\
8o\x98$\xa1\xba\xdc7\x07\x16"U\r~\xea\xb1\x0c\xd6@\xa8@\xca\xef\xc3Q\xa5\t>\
\x89\xec\x80Do\xc2\xee\x16y#\xbd\t\xd2D\x91\xca\xbe9\x12x\'\xa6\r\x91\xd4\
\x81\xc6\xfdFzC$\xd9\xb5|o\xa4\xb7B\xa2F\x83\xd5bO\xa4\x91\x82\xdf\x1e\xec\
\x83\xa4\xbe\x05\x89\xf4\xab}\x90\xa4\xe9C\xc1\'\xfc\xcb\xfb\xde\xa6\xd4lqh7\
\xa4\x91LOl\xb5\xaf \x9329\xbcU\x8cc\x92\x9b\xe5\xe3\xff\xbfE{}\xdd\x18\xe9\
\xc2\xfb\xebQ\xb9R\xf5\xa5\xfa\x1c=\xa1\x06J=3W_\xaa\xcf\xd1/\xcb\xd8\xb0\
\xf5](\xa5\x8c\x00\x00\x00\x00IEND\xaeB`\x828\x07\xe8G' )

def get52Bitmap():
    return BitmapFromImage(get52Image())

def get52Image():
    stream = cStringIO.StringIO(get52Data())
    return ImageFromStream(stream)

index.append('52')
catalog['52'] = ImageClass()
catalog['52'].getData = get52Data
catalog['52'].getImage = get52Image
catalog['52'].getBitmap = get52Bitmap


#----------------------------------------------------------------------
def getMaskData():
    return zlib.decompress(
"x\xda\xeb\x0c\xf0s\xe7\xe5\x92\xe2b``\xe0\xf5\xf4p\t\x02\xd2\xee@\x9c\xc0\
\xc1\x04$\x0fT\xff8\x06\xa4\x98\x8b\x9d<C888n?\xf4\x7f\xc0\xc0\xc0\xa4\xe5\
\xe9\xe2\x18R1\xe7\xed\x9d\xd3}\xab\rx\x1a\x12o\xb3x\xb0\xacX\xf1\xe8\xef\
\xfd\xf5+t\x97^h\xcb6\xe2>\x7f\xb3\\\xcc\xfd\xc4\xd4\xfd\xaa\xda\xff\x95N^\
\xea\xe8\xf88\xbfr\xde\xda\xad\x0c\x1b\xdeWORQ8\xf8\xf8\xe3\x8a\xd7U\xb7\xcd\
\\|&\xb1\x08~\xb6Q\x7f\xf7r\x17\x9f\xe0\xda\xad\xbf\xf7\xb5\x0b,Qat\x88\xbd\
\xfe\xd8B(p\x92J\xed\xfd\xe3\x12\xd7K\x97\x16\xca$\xf7\x9c\xde\xc4p\xe0o\x9d\
\xff\xa4\x96\x0e'\x0ew\xff\xdf\x9a\xefk#\xa7\xb9\x88$\xdb\xcc\xf5c\xd8\xb0\
\xee\xf5\xfb\x8f\xceGro\xf7\x18\xfe\xde\xa7\x7fz\xd2\xb2\x95\x86\xcf^4\xfeo8\
\xaf\xc8\x10\xb3\xfe\xfa\xb2\xcc\x8e\xf3r\x0c\x12\xc9y\xdbg\x7f\xbfg\xf9|\
\xaf}\xd59\xff\xa3\x12\x8c\r\x93om\xcb\x9d\xc5\xc6`p\xec\xc5\xde\xe7\xab\xb7\
\xe5\xce.\xce\x8b\x9c\xa6s\x9aO\xee[\xf2\xbd\xea\xec\xb7&\xbe5\xfb\x9eU\x9e\
\xfb,3\xff|zh(\x83\x80\x93\x82\x92]\xfb\xfa\xeb\xab5\xba\x16\xb3\xff\x139\
\xcf\xc3\xf0z\xd7\xb2\xccW{\x97\xafZ5-\xf5a\xbam\x8b\x82^\xe7}V\x86\x07@\\9O\
\xb9\xfe\x97Q\xc9\x17\x86\xff\xada'\x17\x86\x16eL\x95\x89Rm\xa75\x93\x85a\
\xcf\xd6\xc3\xd5\xe7W\xd7\xc6\xad\xbf~1\xf8/\xe3z-\xa6\x86\xccY?\xbc9\x1a\
\xdb\x12OlzSn)|q[\xaek \x07\x97\xb3\xcb\xbdg\xc9k\x9f\xee\xa9\x9c\xb7\xbfX\
\x9a\xaf4\xf6\xf9\x9c\xcd\xd7\x96e\xfe\xaa\xdb\x7f\xbc\xf0\xcc\xa6\x1c\x89\
\xb6\xc5\xcb\xffN\xd9*&8\xb7\xf8\xd8\x8cm\xb9\x9fm\xd8\xef\xc5|i\x8d^\xf6\
\x83+VO<\x99'\x9f\xa5\xf8\x9c`g\xa5t\xa5bX\xec\xf5=\xd7\x96g\xce\x12`\x9a\
\x9a\xda\xd9Q3\xf1\xdcs\xe3\xfc|\xe1\x90\xa7s\xa4\x8f\x1b\xb64t\xd4\xdegv\
\x98\xb5\xec\xc7\xd4\xd9\xdf\xea\x18\x16=\xf0\ty\x19\xa7\xb8\x1f\x98\x88\x18\
<]\xfd\\\xd69%4\x01\x00\x8aK!5" )

def getMaskBitmap():
    return BitmapFromImage(getMaskImage())

def getMaskImage():
    stream = cStringIO.StringIO(getMaskData())
    return ImageFromStream(stream)

index.append('Mask')
catalog['Mask'] = ImageClass()
catalog['Mask'].getData = getMaskData
catalog['Mask'].getImage = getMaskImage
catalog['Mask'].getBitmap = getMaskBitmap


#----------------------------------------------------------------------
def get39Data():
    return zlib.decompress(
'x\xda\x01\x05\x03\xfa\xfc\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\
\x00\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\
\x08\xdb\xe1O\xe0\x00\x00\x02\xbdIDATx\x9c\xedZ\xdbv\xc3 \x0c3=\xfd\xff_f\
\x0fl,M\xc0\xf8"H\x9d\x83\x9e\xba\x95\n\x8c\x03\x16\n)\xe7LD)%z\x04J8o"J)\
\x95?\x1e\x80\x12K\xa2\xbf\xf8\x1e\x83\x94\xd2\xeb\xee1L\xc1\xbb~*K\xeb\xba\
\xcc"f\xb2\x91\xab\xd3\xce\x11q#\xe9>\x819\xe7\x88Y*x\xe6\xba\xdaQ\xc5\x01 *\
\xecv\x02a\xf3FU\x06\x81\n\x0c\xc5\xe6\x8a\xea\xd8\xbd\x7f(@6{T\xd7\x8e=C\
\xc1\xb2u\xa3J)1\xbc\xbd\xaflC\xc1\xb2Q3\xaaS\xf1\xbd\xd6b\xbe3\xedP\xb0l\
\xbf\xbf"\xa5\xd2\x13v#\xe4\xc4\xb2U\xce]\xaf4\xcf\x83\xa4%\x96\xed\x88vT\
\x11u\xfa\x11\xdd\x93\x08<\xb0\x953u\x8eJ[\n\xcb:\x1e\xaef\xe1L\t\xd9\x86\
\xf8\x88jX\n\x99M\x9f\xf9\xaa7S66\t\xda\xa7\xfa\x13\x18\xd2\xfa\xab^\x9b&\
\xed\xb0\xb1\']\xde\x9d}\xf8\xb8\xaaD\x03P\x07\xbe\xc7M\xfa\xe0gt(\x1a\x9c\
\x8f\x19\x83\xff\\U\xd2\xd3\x92\xb5u\x86\xadWZ|\xe4\xea\xb8\xc0B\x1b\xbaS\
\x14\xd3<\xd1 Dc]\xc5MQ\xc5V\xb7\x1d\x00%\x88\x90m\x88)n\x8cY4\xa0$\xa8\xebM\
\x0f\x1fL\xb3\xa5\xa4\xcd\xb0\xe5pT+\xdc\x18\x89h\x00{;d\x9a\x15\x9bh\\\xc6f\
\xc9\xd5\xf7\xbb1\xea\xa8\xd6\x1f\xdd\r\x81\xedz\x15\xdd\x8d\x89\x8e\x1dU\
\x0b(\xff\x04\xcb\xa6\x8b\n\xeb\x9f\xacpcl\x80\xf8\'X\xb6\xe9n\xcc]l\xfb\x1e\
S\x1c\xec\xa8\xe2\xc0\xe5r\xa2\xceyp6W\xae\x98\ns/\x9b\xeb\xbdpuE\xcd\xb7\n\
\xb1l\x95\xd3\xa5\xd9\x99\nc\xd0\xecN\xb6#\xf6\x8d\x9f8\xd8QiV\xadA\xb3CZ\
\x16\xec\\\x11\xd1\x1dI0\xd4.K\xae\xf8n\xb4\x83\xc0\xb2\x15\xd8O"\xf2\x97\
\xf3\x12)\xa4z\xd5?\x1c\x98}]]\xbb\xec\rB"\x85\xe4l\x12\xcc:\xe1\xdb\xa4\xd0\
W\x9c\xf0k\xf7LH\xa4\x91B(\x8fi\xca\t_%yf\xf4\xfe\xccz\xe5:5\xde\x0bf\x11N\
\xc9\xd5<)$D\xc8\'\xb0\xdcJ\xaf[K\xf9\xf3\xa3\x01M\x9b0\xe1\x1dG m\xad\x1c\
\x13\xdd\x982\x8b\xfc\x08\xe4l*\xccuc\xe4JB\xc2&\xc7\n7\x86I\x82S\x824i\x17\
\xb91\xbd$8%\x08\xf3\x9fEn\x8cP\n\xc9\xdd\x18\xfeq]\xb7\xb3\xc3wZf\xa6B\xd6\
\xab\x8a\xdeLm7&\x0e,\xda\x02+\x1a\x0cl\xcdzp\xfc\x1c\xcf\x8d\x91X\xf0\xc6\'\
P%\x1af\xb0\xe5\x9c\x99oW\xb81\xeb\xd9\x9e\xf9Vn\xdf\xf8a\x87\x82\x02\x84\
\xed\x99\xf5jG\x15\x07Q\x9d3^\x91\xc4\xcb\x95\xe4\xea\xe0\xbes\x16\x07/\xde\
\xdf\n\x87b\xe64\x0c\x9d\xd0(\xe1\xfc\x00\rwL\xce\x9c\x08\x87\x86\x00\x00\
\x00\x00IEND\xaeB`\x82\xa4ef\x95' )

def get39Bitmap():
    return BitmapFromImage(get39Image())

def get39Image():
    stream = cStringIO.StringIO(get39Data())
    return ImageFromStream(stream)

index.append('39')
catalog['39'] = ImageClass()
catalog['39'].getData = get39Data
catalog['39'].getImage = get39Image
catalog['39'].getBitmap = get39Bitmap


#----------------------------------------------------------------------
def get07Data():
    return zlib.decompress(
'x\xda\xeb\x0c\xf0s\xe7\xe5\x92\xe2b``\xe0\xf5\xf4p\t\x02\xd2\xee@\x9c\xc0\
\xc1\x04$\x0fT\xff8\x06\xa4\x98\x8b\x9d<C888n?\xf4\x7f\xc0\xc0\xc0\xf8\xd9\
\xd3\xc51\xa4b\xce\xdb9w\xf3\x0e\x1bp\xb8%\xbe\xfa\xbd\xbf\xa8\xec\xa1\xe9\
\xd9?\xcd\x8b\xafm\x90\xed~\xaf\xe7+\xfa[\xa4\xa7\x90\xe5\xeac\x0b\x17\x97\
\xd0Tn\xd19\xed\x1d+\xb2v\xdephu}zr{o\xc8\xd7\xd7\xeb\x9f?X\xe4^\x1a\xabk\
\xb0B\xb2\xfe\xe6\xaa^\xc9\x0b\x1aA\xb7\xbd\xf4\xbe5*y\xba\xb2~\xdd\x1ev8\
\xe3\xa0\xe9\x94\x9e\x15~*+\xbeZ\x85\xf8yL<\xb6~e\xcc\xc4C\x07~M\xfc\xeb\xc3\
7\xfd\xcc\xe3_\x13$6\xf4\xb1WY\xc71D\xa4\xef\x8f\xb2x\xf5"\xf0\xde\xcf-\xc9r\
\x19\xff\xad\xd6\x89}>u3\xdf\xefV\xe6\x0b\xdb\xe22\xf1U\xbf\xef=}\xd2>\xf9\
\x0e\xd3\xaa\xc4\xbcF6\xe9gb\x9bD\xd6\xb8\xb4nXs\xe9\xe9\x95\x88\xb3\xff\xaa\
2\xefD\xad\x08O1g\xb0\x93\xb7\xfe$  r\xf3\xf1\xe7\x03~\xc7\xb6\xc4|l\xdf2}\
\xed\xb9\x8d\xab\xa7\xfa\xdaX\x94\x19\xa9\xfdr\xac\xb8\xdds\xb2\xaa\xf8\xd8\
\xd5y\xdb\xbc\xb4\xfa&u-^\xf2Hc\xa5\x05\x91\xcc\x8e[\x12\xea\x92\xa5\x8a\xd5\
\xb7\xb8<Co\xb1\x9f;\xb5d\xdb\xec\x86\xeb\xd7-\xd6\xfe\x08\xbe\xdaQ*z?T\xe2a\
\xa3\x9b\xee\xf2\xc9J\xab\xbe\xf8\x1f\xcf\xe8v\xbb/\xbd\xebu\xcb\xf5cG;\xaa\
\xca\x16O+\xf6\x8c\xcd\xff\xed\x19\xc0\x13\x13\xe7\x9bWmj\xb4I\\\xf2\xea\x93\
\x04-I}o\xa0\xc7\x0c\x0fh\xaal\xca5\x9dt]/Fh\xe6\xcb\xf2{\xd5;do\x1e\xbd\x1a\
\xf6m\xc9J\xd9\x06\xa3y\xbf\x84\x96<^\xf9m\xda\xef]\xb3\xde\xcd\x90_\xf5\xba\
\xd7\xd1rw\xf9\xfe\x1f_7\x16\x86\xfe\x92\xfb\x1b\xfe\xff\x91\x8eL\x9b\xca\
\x85\xbfY\xaf\xce{\xacR:\xfc#aU\xf0\xdb\xean\xd9{s\xb6:\xdd\xca\xda\xc5\x1e\
\x94\x9b\xea\x1e\xb2d\xed\xb2_\xbb&\xc74\x7f\xf9\xfc>7\xfa\xdf\xe5{\xe6\xf5\
\xfe\x7f\x0e\xc6\xbf{\xdc\x07L\r\x0c\x9e\xae~.\xeb\x9c\x12\x9a\x00\x08n\x1a?\
' )

def get07Bitmap():
    return BitmapFromImage(get07Image())

def get07Image():
    stream = cStringIO.StringIO(get07Data())
    return ImageFromStream(stream)

index.append('07')
catalog['07'] = ImageClass()
catalog['07'].getData = get07Data
catalog['07'].getImage = get07Image
catalog['07'].getBitmap = get07Bitmap


#----------------------------------------------------------------------
def get11Data():
    return zlib.decompress(
'x\xda\x01|\x02\x83\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x024IDATx\x9c\xed\x9c\xdb\x96\xc3 \x08E\xa1+\xff\xff\
\xcb\xce\x83\xd3\xd4z!\x99\x06H\x0f\xc3y\xcbe\xa9;\xa0\xe2%r)\x85\x88\x98\
\x99B\xa8\xe2lD\xc4\xcc\xf5"\x80*\x0b\xd3\x93/\x8c\x98\xf9qw\x19L\xb4\xb5\
\x17\xd3\xda\x85h\xc9\x98\xb6\x9aP\x95Rv\xfb \x1a\x8a:\x0f\xdc\x19\xaa+\x82"\
\xd1\xd4V\xe8H4R\xed\r\x063\xe3v\xcd\x07\xad\x85"\x98\xe77\xda\xba\xeb\xd6\
\xf1\xd4\x91\xdc\x82\x18\x8f\x96\xbd\xfd:>\x16{\xa3\xb2\xa8Kc\x82\x0e`\xbd\
\x07\xea\xe6\xbaJ\xca\xda\x15\xdfl5\xe6t%o\xf9\xeb\x98Z\xcc\xaak:Yh\xa3\xac\
\xffM\x1cx]\xe7\xbd\xcb\xc8\x0f\xe7T\xb8QE\xd52\x0e\x84\x06[\xc6\x81\xa4\nV[\
\x05\xb7\x88\xb9\xef\x85\xbb\xc7\x9f\x81u\xa5o/\x85G\x8az\xb5\xec\x02\xc0\
\xf5\xbc\xf7\xc4\x1d\xcc\xe5\xd4\xb2\xfb\xc7\x81\x93\x88I]\xfe\x03\xd0\x97\
\xad\xba\xb9\n\xe8\xa9\x8bI\xc4\xe4Y\x07,\x146b\x9a\xd4+P\x13\xb5\x8ai\xab\
\xa4\xc2QR\xe1(\xa9p\x94T8J*\x1c\xf9QyN\xef8Q9\xcf[\xc5\x1c\xe1\x9bS\xdd\xb2\
\xd2cK%\xac\xf4\x98\xe6kHu\xe3J\x8f\x15\xd5\x99B\xdb\x81e\x7fuZ_\xba\xd2\x83\
\xae\xa4\xba\xa0;Wz\xb4\xf4E+=\xa6\xca\x95\x1e\x05E_\xe9\x89\xa4\xa4\xc2QR\
\xe1(\xa9p\x94T8\x8aI\xe5\x111\x19I\x88\x98c\xda\n\x92\xaa\xee\xbb\xdfG\xa2\
\xe36|\xbc\xdfw\x0ew\xfc1\xb3G\xbd\xea\xca\xe1\xf0\x11=<P\x18\xe1\x1b\xc9c\
\x97\xfe\xee\x18\xe3\xa6\xd1\xcf\xb2\x96\xff*\xb5\x1a\xe1\xf7uw=\xc2W\xd9\
\xd7;\xdeA]\x95\x93\xbd\x1a\xb2e\xaf\x12\xe6\x18\x81\xa9h]-=f9U\xde\xfc\x93\
\xb0m\xb5\x92U/\\\x03\x99\xc3w>N_\xee\xd9\rm%\x17Z\xf7/\xbc\xee\x8e\xad\x07\
\xae\x8a\xaeR\x9d\xcaS\xe3#\xf3z\xa5\xfb\xaf\xe4*\x8b\x1bza\xff8\xd0i,\\\x1b\
\x0f]$!\x9e\xf4k\xd9\x15\x91\x0e\x93B\xed\xaf\xe4\xa3EP\xa9H<\x87\x03\x95\
\xaaE\x1a\xe7- g\xce\xda\xa3E\xa6/\xa0\xdaJ\x16\xa4\xad\xc2\xb6\x81\xb2\x1eg\
\x82k \xfd\x9e\xde\x16\xf2\xa4\xbd\x1f\xe1t&\xe0\xeb\t\\4\x00\x00\x00\x00IEN\
D\xaeB`\x82=\xf83B' )

def get11Bitmap():
    return BitmapFromImage(get11Image())

def get11Image():
    stream = cStringIO.StringIO(get11Data())
    return ImageFromStream(stream)

index.append('11')
catalog['11'] = ImageClass()
catalog['11'].getData = get11Data
catalog['11'].getImage = get11Image
catalog['11'].getBitmap = get11Bitmap


#----------------------------------------------------------------------
def get15Data():
    return zlib.decompress(
'x\xda\xeb\x0c\xf0s\xe7\xe5\x92\xe2b``\xe0\xf5\xf4p\t\x02\xd2\xee@\x9c\xc0\
\xc1\x04$\x0fT\xff8\x06\xa4\x98\x8b\x9d<C888n?\xf4\x7f\xc0\xc0\xc0$\xe7\xe9\
\xe2\x18R1\xe7\xed\xec\xbb\x93\x0e+p\xb4&.\x7f\xff\xff\xd4;\xd6\xd8\xc9\x81\
\x8a\xff6\xf8\xf6?\xbcc\xea\xdb\xffs\x91\xc4%F?MAA\xe3\xcbbBs\xc4\x05\r7\xd7\
\xdcp8t\xe8\xcb\xf1\xed\xbd3~>\x7f\x97\xfdC|e\xc8\x99\x1e\xe9\x9c\\\xad\x18\
\xb9\xc0f.\xd9\xce\xacU\xbc\x13V,8\xe5\xf1b\xf7#\xc7\xad\xbcB\x99\x85S9\xab\
\xcb\x9c\xee\xbb\xbe~\xb4\xed\xd7\x9eI\xdd\x1f\x98>\x17\x05\x17so\xdc\x16\
\x9el\xf8\xe7\xd1\xa5\xafE\xd1\xa7t_Y\xef*\xea\xaf\xbd\xab7\xef\xd0\xac\xaf/\
\n\xa3\xf7\xe5\x99\x88\x87\x7fKX<\xfd\xd1\xebo\xffDy\xd7=8\x97he[{w\xd3\xf3\
\xc3E\xdf\x96\xfd\xba\xee|~\xe6\xbe\xbct[\x9d\xf4v\xb6\xcdE\xdf\xe4\x0c:\x93\
\xd7_\xb9xz\xed\xdc\xcd\xd9\xee]\x1f\xcf\xc9\xf7\xae7\xf9\xb9kn\xe9\x9b7\xc7\
\xceH,\xdb7s_\xf7\xedW\xe7\xecv\xc5\xd8?\xfb\x16\xf5s\xe3\xfb\xd93\x16\xdf6\
\x0c\xbf\xb9\x85#\xf2\xc8\xf4\x13n\xc7Z\xfe\x05\xed\xc9=v\xa5C\xfb\x82\xa6U\
\xf6\xf9\x9d\\Z2\xac\xa2}M\\\xee\x8e\xad\x8b\x17\x1c\n\x0cx\xa8\xb1\xa2@$\
\xc4\x02\xaf\xf0\xb4\xac\xe4wS\x03\xc57=\x8fq\x0c\xf2\x9c\xef\xbe\xceg\xd5m\
\xbb\x0f\xbf\xa4\xf4\xb5\xff\xcd\xa8\xd4\\\xb7o\xf3\xe2&\xb1\xf0\x05\x81\xb5\
\x95\xebo\x07M\xad\x9b\xf7q\x97T\xc9"\xaf\xfd\xf7\xd7\xee\xe4\xf8ly\xd84=5\
\xe0\xd5\xd5\xe9\xc2_\xdf\xfc\xcd\xfb\xaa\xab\xdd\xb7\xe0[\xfc\xcd\xd3\xa2E\
\xe9\xe2\x92\xa9\x8f\x0e\x84,q\x7f/\x11\xfa\x7f\x9fQ\xe0\xf9wE\xcb8\xaa\xd7\
\x99\x9c}"6\xfd\xe2\x9b\xdb\x17Bw\xdf\xec\x9fp2+\xe9\xf7"\xf7\xf7\x13\xd7\
\xcf\xce(b\xcdj>\x1b{d\xc5\xed\xd4\xb5\x7fkbb\xed\xb8\xf2K\xa2\xcf\xde\xb4\
\xbf\xff\xf7\xd2\xe4\xcd\xeb\xdf5\xde\xbfY\xdf\xfa\xbdN\xd5j\xfb<q\xe3=\xce\
\xee\xae\xc5\x17\x93\x823\x0b;|Uoi\xa5\x8b\xdbj\xa4\xbb\xff\x9d~\xf9\xde\xf6\
\x8d\xcf\xbd\x84\xcb6\xc7\xaf\xfd>\xdf\xf2\xf6\x87\x8e /\xcd\xa5\xf1\xf3\xfc\
\xdc\x8f\x9at\x88\xd9\x00\x13\x0e\x83\xa7\xab\x9f\xcb:\xa7\x84&\x00\x03\x05,\
\x83' )

def get15Bitmap():
    return BitmapFromImage(get15Image())

def get15Image():
    stream = cStringIO.StringIO(get15Data())
    return ImageFromStream(stream)

index.append('15')
catalog['15'] = ImageClass()
catalog['15'].getData = get15Data
catalog['15'].getImage = get15Image
catalog['15'].getBitmap = get15Bitmap


#----------------------------------------------------------------------
def get19Data():
    return zlib.decompress(
"x\xda\x01\xa8\x02W\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02`IDATx\x9c\xed\\\xc1\x96\xc2 \x0c$\xfb\xfc\xff_\xee\
\x1e\xd0\xcaR\x08\x01B\xdaa3'}\xd5)\xe34\x10\x02H\xc7q\x84\x10\x88(l\x81(\
\xe7\x15B \xa2\xf8f\x03D-\x14>\xfa\xb6\x01\x11\xfd\xdc\xdd\x86%x\x9d\xaf\x8a\
\xa1\x05j\xe3\xee^E\x80\x9a\x93\xe1\x7fx\x95F\x17\xaeo\x9cW\xb8C\xf3\xd7\xab\
\xcc\x19\xb9$\xddA\\\x85m6\xae\xa2x-W\xb5\xd8\xbe\xaa\x88\xa8\x97.\xfd\xfc|S\
\x14\xd9\xc6\xbd\xba\xdex\xa6)\xbal\xb9*\xfa\xa0\xb7\x113M\xd1e\x0b\xa9\xaak\
\x8c\xd6\xa2\x96\xbf\xd9\xccc<\xcf\xf6\xfeV\xe8\x1c\x97\x84\xb7\x11r\xea\xb2\
\x9d\x9c{\xe6\x16}\xaa\xba\x061c\xb6\x14eU\xb8YEDA\x95\xee\xc0z\x0b\n={\xf1u\
\r1\x8e\xb52&-\xb6?\xaa\x9aCav\xbf\xf4-s\xa9\x06]\xb6\x14\xdf\x9e\x9dq\x86!=\
\xbf\xa5b\x97\n\xdbl\xcf\xfe\xd8<0\x9f5vAwZ\xa9\xc8V\xc8\x98\xb2\x90E\x9c\
\x11\x172&\xddP\xb1\xc7\xb6\x19S!\xae@-J\xb1\xa7W\xae\n\x07\xae\n\x07\xae\n\
\x07\xae\n\x07v\xaa,K\x06F\xaa\x8ck!\x16\xaat'\x97\x12,W\xa5\xbb, \xc4ZU\xea\
\xcb\x02B,T\xb5bY@\x88U\xaat+\xd2\xbd\xf0\xf1J\x8cu\xcb\x02B\xb8W80R\xa5\xbb\
\xc8\xd0\xc4\x12U\xeb\x96\x05\x840\xda\xcbiY95\xaar\xda\xe7\x81S\xab\x07B\
\xd8\x97M\xbd\x0f\xc4\x81\xab\xc2\x81\xab\xc2\x81\xab\xc2\x81\xab\xc2\x81\
\xab\xc2\x81Ev\xbb\x08\xcc\xecfO\xaf U\xc5\xbd\xe9g\xd5\xe0\xbaU\x1d\xef\\cs\
\xc7\x1f\x11M\xc5\x15\xbf'\xf2F\xb6\xa9'\x90)\xb3\xdc\xcb6\xb5K\xfft\xfc\xba\
\x1bt`\x97\xbe\x9c\x8d?X\xda]\x8d\xc9\x83\xb2^f\x19X=\x90\xb35\x0f\x7f\xa0\
\x9e\xbf\xe2\x1fW\xc8\x9e=\x82\xa9\x07\x03\xab\n\xf5\xe8\xedS%\xefW\x06\xf6\
\xb3\xab|2\x02\xdb\xab\x1aFr\x8bf4\xeb\x1e\xe8*\xb21\xbd\xe2`\x9d\x9dot\xefo\
4\xc0\xd6\xdc\xed0\xf8\x04\xd6\x9a2\x96\x13\x8c\xb1\x1d\x1f\\/\x8d\xc7\x95\
\xfc\x1c\xa4=\xdb\x0ey\xe0\xd5\xb1\xd9>\xf0\x99\xe7\xaf\xf0\xe6WA=\xbb}\x08\
\x9a6\xa0Vc\xb2\x01*\xbb\n\xe9U\x13\x90^5\xd3\x11\xf7\xea1h\xf6\x16{z\xf5\
\x13\xab\x84w7C\r\xef\x7fo\xdb\xf2\x9f\xf6~\x01\xd6\xe1b\xe5f\x061\xf3\x00\
\x00\x00\x00IEND\xaeB`\x82r\xb0<\xa0" )

def get19Bitmap():
    return BitmapFromImage(get19Image())

def get19Image():
    stream = cStringIO.StringIO(get19Data())
    return ImageFromStream(stream)

index.append('19')
catalog['19'] = ImageClass()
catalog['19'].getData = get19Data
catalog['19'].getImage = get19Image
catalog['19'].getBitmap = get19Bitmap


#----------------------------------------------------------------------
def get23Data():
    return zlib.decompress(
'x\xda\x01\x88\x02w\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02@IDATx\x9c\xed[\xd1\x92\xc3 \x08\x84N\xff\xff\x97{\
\x0fN\xad5\x84(\x90\xa4\xeb\xb1o\xb9fV\xf6\x10\x150\xfcz\xbd\x88\x88\x99i\t\
\x149O"b\xe6\xf2\xb0\x00\x8a\x16\xa6\xb7\xbee\xc0\xcc\x8f\xbbm8\x05\xcf\xed\
\x9f\xda\x18\x03uc\xef\xab5\x96\x8d/_UI\xa0.\xaa\x10\xe2\n]\x12\xfd\x97\xb8\
\xea\x00\x1af\xf2\x0c,\x18\xa4\x88U\x1e\xc2\xe6\xdd\xaf\x8a\x11Q\xc2\xa2\xd8\
\\\xaa\xda\xe1\xfd\xa6\x04\xb2\xd9Um\x07\xf6\x98\x12\xcb&\xa8\xe27\xa6\x8c\
\xf0\x98\x12\xcbF\x9d\xaa\xed\n!\xae\x196\xc1\xb6\xf7\x8d\xff&\x9a\xdc\x94\
\x06\x87\x19\xe4\x8ce\xab\x9ck\x9e\xd9\xe7T\x8d\xcf\x87\x917c\xd9Z\xc8\xaa@\
\x8f\x14\x15\xf2\x1aH\xe0\xc2\xb4\xfcjDX\x89\xe3\xa8Cp\x14\xdb\x97\xaa\xc3\
\xad\xb0\x1b\xaf}T~\xdaC,[\x8b\xcf\xca\xaexF!\x8dM4C\xd8\xbc+\xfb\xcf\x9e\
\x03\x85\xacq\x1c\xb19e \xdb\xc7W\x95\xb4\x0bY\xc4tX81\xa1\xd7d\x96=1\tq\x05\
\xea\xa2\x16k\xfa*U\xe1 U\xe1 U\xe1 U\xe1 @Uv\x0f.b[3k\xfc7\xdd\x03\x9b\x11\
\x1eS\xce\xed\x1e8\x8d\xb0\x99rF\xf7`Z\xd5\xf5\xa5f\x83\xb0\xdc\xaf\xd0\xbb\
\x07\xe8HU\x12\x00\xba\x07\x83\xa3\x8a\x8f?\xda=\xb0!\xbb\x07\xd7\xb1\xe5\
\xbd[\x1c\xa4*\x1c\xa4*\x1c\xa4*\x1c\xa4*\x1c\xa4*\x1c\xac\xa9\xcau7\xe6^(i\
\xcb\x9a\xbe\x82TU.\xa6\xd7r\xc0\xf6\x9e:^~ux\xe3\x8f\x99]q\xa5\xdf\x89\xbc\
\x91\xcd5\x03\x95\xfa\xc9\xbdl\xae[\xfa\xd5\xe3\xdb\xdb\xa0\x86[\xfa\xe3l\
\xe2$\xac\xefLg\xf8}P\xee\xd7O\x0c\x15\xe9q\xb6\xc3/?P;\xa8\xfat\x85\\\xd9\
\x0b\x94B/\xb0*\xda\x8f^WE\xda\xf9f,[\x0bl_\xedaZ\xd5\xf5N0\xec]\xc6\x13\x93\
\xedC\x85@6e\xad\xb7W\xa4\xf7\x06\xb3\x9d\tf\xd9\x0e/g\xd8\xe3j\xf0#\xc8\xf3\
\xd8\x94\xaf\xb5\xd7<\x07f\x07U5%\n!l+\xd4-\xb6\x80\xdc\x85\x0f\xfd\x89\xea\
\xabn\x83\xea~\x85\xf4U\x0bq\x1e\xa2\xfaJ\xcf#\xe1}ER\x98\xa1\xfaJ_0\x1e\xa5\
Jx\x995g\xa3\x14s\x84\x82\x0e4\x8a\x9c?\xb4\xf1{\x01\xcb\xb5K\x8f\x00\x00\
\x00\x00IEND\xaeB`\x82\x80\xd7/\xd6' )

def get23Bitmap():
    return BitmapFromImage(get23Image())

def get23Image():
    stream = cStringIO.StringIO(get23Data())
    return ImageFromStream(stream)

index.append('23')
catalog['23'] = ImageClass()
catalog['23'].getData = get23Data
catalog['23'].getImage = get23Image
catalog['23'].getBitmap = get23Bitmap


#----------------------------------------------------------------------
def get27Data():
    return zlib.decompress(
"x\xda\x01\xb0\x02O\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02hIDATx\x9c\xed[K\x96\xc3 \x0c\xb3\xfbz\xff+g\x16t(M\
\xc01 H\x95\xa2]fR\x19U|l\xa0\xbam\x9b\x88\xa8\xaa\xdc\x02A\xceSDT5<\xdc\x00\
A\x8b\xca\xbf\xbe\xdb@U\x1fW\xb7a\x08\x9e\xe9Cvt1:\xf9\x03^\x05Dsx'\xc6\x0fU\
ig\x0b\x92\x18\xbb\x9f\xdc\xb5\x07\xe6UQ\x1b%\x10\xaf\xb0\xc3\x0f\xc2\xd6\
\xab*4\x02%\x0c\xc5\x96Q\xe5\xef~i\xf8\xfe\xa6\x00\xd9\xda\xbd:\x06\xeei\n\
\x96\xadQU)d[S\xb0l\xd2\xa6\xca\x0eV\xdb\x14,\xdb\xebSR9\x83;\xc389\xb1l\x91\
\xf3\x97V\xe1\x12\xfc\xfd\xc1\xf3&\x96-\x85\x95[\xf0\xa2\xb8^Q\x0b\xdb\xab\
\xaa]\n\xc38Fe\x8c(\xb6\x0fU\xa7K\xe1.^\xfah\xfc\xab\x04,[\x8a\xf7\xccn8c\
\x90\xc6OA\xec\x82\xb0\xf5\xce\xec_\x9b\x07f*|?\xb0\x05\x18\x90\xed\xedU$\
\xdd\rY\xc6\xda1\x931a\x87JJ;\xe7\x0b\x9a\x971M^\x03g\xecO\xd8\xcb\xc3\x88p\
\xc3\xbd\xc2\x96\x83N\x8cU\x05/\x07\x9d\x18\xa8jD9\xe8\xc4(U\xd8J\xa4\x16\
\xabjtc\\9\xe8\xc4\xf2\x8a\x07\x93Ta\x8b\xcbS\x0cQ5\xae\x1ctb\xd2\x89\xce\
\xa0\x8c\xb9\x14k\xc6IOU9\x08\x99\x15{\xbdZ\x15\xfe<\xb6u\xd2\xe3\x08\xb9Nz\
\x86\xb0\x05T\xab\x9a\x7f,\xd0 leL\xec'=\xecX\xaar 8\xe9qF\xcd>~\xe9IO\x1bV\
\x1e8\x8f\x8d\xfb\xc6\\\x16\xeb\xbe\x05\x15\x96*\x1e,U<X\xaax\xb0T\xf1\xa0\
\xebn\xcc\xb50R\xe1{zE\xa9JU\xe3M\x9bm\xdb\xc2\xe3\xc7\x0b\xc2\x96\xb3\x9f\
\xde\xf8S\xd5\xaeq\x85\xbd\xf4\x02d\xeb\xea\x81FM~-[\xd7-\xfd\xe8\xf8\xf16h\
\xc3-}?\x9b\xfd\xab\xd2\xea\xaaq?(\xcb5y\xc3.\xa7\x9f\xed\xf8\x95\xed\xfe\
\xc2\xfa\xfb+\xbb\xbbR\xce\xec\x01\xc6\xe6!\xb1*)\x8f\xde\xae]\xce\xce7\xb1l\
)\xb8\xbd*\xa1Z\xd5|\x13J\xef\x1c\x13\xa5\x88\x16\xaf\xec\xa6\xd4\xf6\x16,[@\
c\x0f,\x05kk\x04\x96Mz\xc6\xd5\xe9Rx!\x1bk\x1e\xa8\xe6\x8f\x9a\xd7\xa9\x9c\
\xd9\x14\x14 l\x94\xeb\x95\xdd\xfd\x84T\xd5)\xf8T\xed\x8c\xca\xae\xc5\xac;gv\
\xb5\xc2\xe7\x95\x07|^y&\xc9{z\xf5\x08\xbb\x84W7\x03\x86\xb0\x99\x93\xd9\xd0\
\xa1F\x90\xf3\x07\xb2\xa1\x8d\x0eD\xd9J\x9a\x00\x00\x00\x00IEND\xaeB`\x825.@\
\xeb" )

def get27Bitmap():
    return BitmapFromImage(get27Image())

def get27Image():
    stream = cStringIO.StringIO(get27Data())
    return ImageFromStream(stream)

index.append('27')
catalog['27'] = ImageClass()
catalog['27'].getData = get27Data
catalog['27'].getImage = get27Image
catalog['27'].getBitmap = get27Bitmap


#----------------------------------------------------------------------
def get31Data():
    return zlib.decompress(
'x\xda\x01\xa5\x02Z\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02]IDATx\x9c\xed[\xd1\x92\x83 \x0cLn\xfa\xff\xbf\xec=\
0Z\x0e(J\xb2\x157\xc7\xbe9\xda\x90mH\x08+\xea\xb6m"\xa2\xaa\x12\x02\x89\xceK\
DT5]\x04@\xe2\xa2\xb2\xf3\x0b\x03U\xfd\x99\xed\xc3W\xf0*\xae\x8b\x04#\r\xe3\
\x9fX\xd55\x83\xb4\x8a\x94\xb1\x92,>\xa4\x94\xa4\x88U\x18\xc4dUV\xf6\x00\xd5\
\xa2\xac\xec\xb6j\x81M?\x88\xb5\xc6\x0c\xdcv\\w\x02E\x0ce\xcd\x95W\xf9\xf0~W\
\x80\xd6\xec\xac\xb0\x8b\x1b\xd6Z\x83\x95\xee\x18r\xc2\xe3\n\xd6\x9a\x14\xac\
\xea\\jf\x97\x8d\xb0\xedy\xe3\xdf$\x83\xe5\xfb\xe20C\xc5\x06e\xed\xb0\x19s\
\x15\x1ecu}>`\x17\xba\xd1y\xd8f\xc5\xdb\xd7&\xb4k\xa0\x90\x13+Y\x8d.\x85)\
\x8fQ\xed"\xca\xdaX\x1fX\x8c\x97_vn}\x02\xd6Z\x8ewe\xefD\xa6c\xf4\xf8\x15$\\\
\x10k\xde\xca\xfe\xd8>\xb0\xb1\xc3\xbf\x0e\xec\xee\x0bh\xed\x1d\xab\xc3h\x91\
\xb2\x94\x1bG\xa9\xfc\xc6\xa6\xca\xfd\x08\xdb1\xf5\x943^\xc4\x8c\x15\x80\x15\
\x87\x1acpb\xa91wX\xfb7j\x8c\xcd\t\x8f+\xdfUc\x9cN\xd8\\\xf9\x86\x1a3\xcc\
\xea\xfe\xad\xbb\x81\xd8Z\xaf\xd8\xd5\x18v,V-\x10\xa81\x17Gm^>T\x8d\xb1a\xa9\
1\xf7Y[\xe7\x98x\xb0X\xf1\xc0\xa5rb\x8f\x9c\x00\xad\xb9b\xd5Ya\xe6Zs\xbd\x17\
>^;\xd4\xef\x1f\x0c\xef\x85\xfd\xd6\x0e\x9b\xae\x9e\xbd\xb3\xc2\x18zv\xa7\
\xb5\x1cKc\xe2\xc1b5\x92\xb5\x86\x9e\x1d\xf2d\xc2\x8a\x95\x88\xcc\x08\x82a\
\xed\xb2\xc4\xaa?\xcc\xa8\x13Xk\t\xc6\x19\xf8i0\x9b\x13Xk\xe2\xc9\xab\x8b\
\xc7\xee\xa6X\x8b\xd9\x07\xc6\xd4\x98\xd6\x0e\x9f\x07\xae]\xe3\\td\xb6\x98\
\xb1\xa2d\x95\x0e\xa6\x1f\xa5\xa5>\xa7\xceW-NO\xfc\xa9\xeaRc*<v\x15\xa6Tc\
\x9a\x930\xffp\x91R\x8d9m\x1aY\xd5\x98\xfet\xa5\xac\xec\t\x9d\xa6\x91\x98\
\x95|\xce\xde\xa5\xc6\xf0\xc0\xd2[\x9cf3\xf6\x83\xae+_\xb6\xe5\xcf\x18w"\xd3\
\xd5\x98\xd3cw\xc4j\xcc\xb6\xa3\xbe\xb5\xd4\x98\xae+\x8f\xea\x03\x89\xd5\x18\
\xdd\xd1\xb8\x05\xf4\xe9N\xe0k\xe0t$Jy\xb5\xc0\xd4\xc0\x87#&\xab\x08\xcaY\r\
\xcaX\x9d.n\xac\xb1\xea\xd7m\xcaX\x9d\xe2\'\xa9\x84\xb3\xdd\x80!\x899\rA\x87\
\x1a\x89\xce/\xbe1\xfb\xcf\x87\n\x9b\xf6\x00\x00\x00\x00IEND\xaeB`\x82\x14\
\x86I\xab' )

def get31Bitmap():
    return BitmapFromImage(get31Image())

def get31Image():
    stream = cStringIO.StringIO(get31Data())
    return ImageFromStream(stream)

index.append('31')
catalog['31'] = ImageClass()
catalog['31'].getData = get31Data
catalog['31'].getImage = get31Image
catalog['31'].getBitmap = get31Bitmap


#----------------------------------------------------------------------
def get35Data():
    return zlib.decompress(
'x\xda\x01\xf2\x02\r\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02\xaaIDATx\x9c\xed[\xcb\xb6\x83 \x0cLz\xfa\xff\xbf\
\xec]pk\x15!\x840\xa0\xa1\xcc\xaa\x9e\xb6\x03c\x80\xbc\x94\xb7m#"f\xa6)\x10\
\xe4\xbc\x89\x88\x99\xc3\xc5\x04\x08Z\x98>\xfa\xa6\x013\xbf\xee\x9eC\x17\xbc\
\xa3\xebh\x8395\xe3\xc9V\xd73\xc3\xe9)\x12\xdb\x8a\x0e\xf6q*\x89"[M\x83\xa5\
\xca\x0f\x12\xaa\xf8\x03%\x05v\xfbA\xd8N\xaa\x0c\xe7x\x98\x04J\x18\x8aM\x8a-\
\x02\xbb \x15\xeb\xdcPlRlQ\xbcaX\xe7\x06f\xa3\xf3]Q\xde0aH\xf32\x06\xb2Ig\
\xa0AR\xf1\xdb\xdel\xff\xff\xa2\xca\xfb\xa1\x1cF\xc9\x89e\xdb9\x7f\xc6_\t\
\xc0:\xb1~.1\xad\xcao\\\x1b\x90\x8e-\xc8\xb9\xb0X\xd5Q\x8cFX\xd8\xc7\xa8\xe4\
\x12\xc5V\x975F\xe3\x1d/\x85\xafr\xc0\xb2\x1d\xf1=\xd9m\xaep\xff\x17\xc4\\\
\x10\xb6\xd6\x93\xbdv\xb9\x0ecKd\xf8z`k5@\xb6\xaf\xadv\xd2h\xcbz,3%"&\xecV\
\x19\x8fi#&\xa9r\xe6\x17\x00[=\xbdna\x9e\xc4\xd3\xea\x16s\xfa+\xbb\xaa\'\xd7\
-\x8c\xaarC\x1a\x13r(\x1b\xd9T=\xbfnQ\xadj|\x92k\x106\xa7\x17\xfe\xa5\xbaE\
\x0f\x8c,\x19\x0cR5\xb8\x16\xd2\xaaJSi\xd0\xbb\xd7.u\x8b"\x0c\x95\x06\xc1\
\xbd\x8e\xa8[\xd8 \'c\xb5\xb5\x10\x07u\x8bZ\xf7\n\x8c\x03{=\xf1\xd3\xa3-\xa0\
\x1fzya5\xee\xea\x94\xefX\xb6\xf2\x83A\xaa\xb0M\x86"\xba\xa8\xea\xe7^\x95h:\
\xd9\xf5OHh\xdc\xeb\x88\xe7-4\x10\x8c\x10\r\x93\xfclc\xd3\xa0\xa9\x87\xbf\
\xb7\x88\xae\xbd"C\x0f\xbf\x9dm\xe7l\xca\x1a\x05#\x18\xb2\xc6F\xb6#V\x95\xd3\
\x0f\x96\xaa\x9a]k\xe8vC~\x19\xb0lEDw\x18\xc1\xe0\xbb,\xb6\x92\x87\xa9\x9d\
\x04\x96-\xc0\xb8\x02s\x83\xd9&\x81e\xa3\x96}u\x1d\xb2%\xcc\xc1\xb2\x8d\x88\
\x03\xc7\xb3\x8d\xa8r\x8egs\xfcVY.\xbbY5\xa6\'\x81\x99\xf7\x84e\xdb\xb6py\
\xfa\x01y[\x81\xc5\xbc\x93\x99\x9b\x9e9{\xe6\x1b\x154\xeb\xc9\xee2\xc3O.\xc2\
co\xc9e\x86_\x0cD\xbcf\xf8\xf2ruy\xb2\x07\x08\x81\x88cU\x94\xdf\xbd+\xc3\xf7\
\x03KlQ\xdc\xcd\xd8\x17\xbarl\xb9\xa3\xdf\x18\xdd>!\xc3/\xb4\xd2\r\xf3\x10xQ\
\xed\x15\x99\xad\xf88\x84\xe3\x0c_\xea\xc24\xce\xe6\x96\xb7_\xae\x86\x05\xec\
\xab+\xdd\xed\x19~\xa4\xb3)\x139N\x05\x05\x83\x13\xbb\x9anN\x7f\xb5T\xf9\x01\
`_\xdd\x05\xc1\x11\xbb\xb4U\xd1\xb9y\xb5\x95|T\xba\xb4U\x11\xafP%\xbc{\x1a0\
\x84bN\xa2\xa0\xe3\x1aA\xce\x1f\x9f\xf3\x16\xee\xb61\xb7@\x00\x00\x00\x00IEN\
D\xaeB`\x82\x03\x95^\x1d' )

def get35Bitmap():
    return BitmapFromImage(get35Image())

def get35Image():
    stream = cStringIO.StringIO(get35Data())
    return ImageFromStream(stream)

index.append('35')
catalog['35'] = ImageClass()
catalog['35'].getData = get35Data
catalog['35'].getImage = get35Image
catalog['35'].getBitmap = get35Bitmap


#----------------------------------------------------------------------
def get03Data():
    return zlib.decompress(
'x\xda\x01\x18\x03\xe7\xfc\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\
\x00\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\
\x08\xdb\xe1O\xe0\x00\x00\x02\xd0IDATx\x9c\xed\x9a\xdbv\x03!\x08E1+\xff\xff\
\xcb\xf6\xc1\xd4XA\xbc\x81\xcd\x99\xc9y\xe8\xea\x988\xb2\xc3\x88\xc8\x18b\
\x8cD\x14B\xa0K(\xe1<\x89(\x84\x90..\xa0\xc4\x12\xe8\x97\xef2\n!<\xfe\xdb\
\x06\x17\xc9T\xe8\xd3\xec6\xbeJ\x8e\x82v\xd7=|\x95\\\x84\xbe\x88\xdd\xc0W\
\xa5\xa3\xa0\xdd\xf5\xe4M\xa0$\xa5\xde\xbej\xc1 B\xd6\xbe\xaa\xb2\'D$\xca\
\xbe\xca\xd6\x97\x18b#\x84\xae\x19\x03\xbf9;\x8e\xeeD\x05\x17\x1e*\xdd#g\x17\
#;\x9c\x84<Po\x81\xd053\xa6;\xc5@\'\x1ds\xfb\x9b*g\x18\xe5\xfe\x8a\xec2\x8f\
\x93\xa1U\xc8\x98\xf2\xc0\x86\x99T\x05\xe3\x9a\xa3\x1d\xca\x98\xce\x87V\xf7\
\xec\xb6\x04\x881V\x97N#\xfa\xfa\x8a#\x95$~\x1es\xa4\x12\xbdt\x06\xcc\x8bJy\
\xf0\x0e\x80\xb9P)H\xf9\x0b\xae`\xf6T\x83\xe1\xc1\x15\xcc\x98JG\xe2$N`\x96T]\
$\x92H<\xc0\xcc\xa8F\x90r\x95\xdb\x1b\xcc\x86j\x10)\x03x\x83\x19P\x8d#Q\x01\
\xe0\n\xb6K5\x82\xa4\xf4u\x02\xdb\xa2\x1aG\xca\x16wWd\x13\xb0u*\xdd-\xfcd\
\xca\xeb|\x07\xdb\x92\xe8\x1d\xd7\xc0\x0c\xe6U\xebI\xab\xec\xe3\xeb\xd5`\xc7\
\x05-R\xb5~B\xd1?$E\x0b\xd1oSc)\xda\xf5\x952O\xcaX\xc7\xd7\xab\xb2E\xbf\xcf\
\x82\xdcw"\xd52%\xb6\xd8\x0fM\xf3{\xd2\xb2\xb0\xc1\x93\xd7V\x14\xc90\xcb\xdd\
\xc7\xcd3\xf3U\xb2\xa0\x1b\xdc\xf5\xb0\xbe\x1f\'\x92\xbc\x9e\xc0\xd6\xb6\x8a\
\xb7xT/\\\xa8\xf4\xf8\xd6\x8a\x93\x86\x12\xce[\xac\xa94N\\j\xf9\xdf\x91\xbek\
2\xa3\xa2\x86A\xd5J\xc5\xffW\xfa.\xcb\xb7r\xa6\x98\xee4\xa3\x92v\xb3[\xc5\
\xb2\xd9\x9c}\xb6\xbb\xa2\x15\xaa\xca\x14nY\x8cQ\xa9\xc3\xf0$]\xbc\x83>\x84\
\xae\xddyU%>e\xa3bS\xc9<r\x87i\xab\xc4Q\x87z\x8e\r\xcc\x83\xdbl\xb8[H}\xd6\
\xe7\xd5\xc8`"\xc0T\x12\xb4\xf6\x8bo=\x81J\x86:h\xcd\xfe\x1dD\x9d8\xc7dntw\
\xb8\xef\xdb\xee%\xb5B\x82\xd3\xce*\xe9\xdc[\xb9\xd9Owd\x99\x07ry\xcf\xd8\
\x96\xbe\xf3\nG\xbeO\xa0\xab\x94\xd5\x1c\xd8W\xb9\xae\xc8?\x82\xa4\xaa\xca>\
\xd5%\x9d\xc9-l\xa5\xac\x079\xff\x82\xf4UW_\xaa\xcfPk\xbe\x94\xedxT\xd4\xd8\
\\\x97\x97\x90T\xa4\x96M\t\x97\x8a\xae\xb7^e\xb5\xe6\x186UK\xd7\xa4B\xcan\
\xc5\xb2\xa9\xd8xM_!QU\xef\xd1\x95F\xa4\'0\xab[\xf0@\xf2\x15\x8d\xa5K\x04\
\xea+\xea\x15\xeb\xc1|E\x7f\x8b\xd8\xe2\xfb\x14B\xa4\x1a\x11$Uu\xd2\x86\x7f\
\x01\x92\xaa+T*%a\'\\*]\xc0TJi\x0c\x98J\xd1c\xe7X\xc3\x07\xeau\xea\xc6\xf5\
\xf4\xe1y%\x9c\x1f\xd5\xfeJ8\xcb \x9d-\x00\x00\x00\x00IEND\xaeB`\x82\xb9u\
\x838' )

def get03Bitmap():
    return BitmapFromImage(get03Image())

def get03Image():
    stream = cStringIO.StringIO(get03Data())
    return ImageFromStream(stream)

index.append('03')
catalog['03'] = ImageClass()
catalog['03'].getData = get03Data
catalog['03'].getImage = get03Image
catalog['03'].getBitmap = get03Bitmap


#----------------------------------------------------------------------
def get43Data():
    return zlib.decompress(
'x\xda\x01`\x06\x9f\xf9\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x06\x18IDATx\x9c\xed[\xdb\xb2\xeb \x08\x85=\xfb\xff\
\x7f\x99\xf3\xa0"\x02ZP;\xbd\x9c\xcdC\xc7\xa4\x89\xb2\x02\xc2\x82\xb4HD\x00\
\x80\x88\xf0\x15R\xe0\xfc\x02\x00"\x96\x83/\x90\x82\x05\xa1\xe1\xfb\x1aA\xc4\
\x9fW\xeb\xf0\x14\xf9\xb5\xa7\xe4\x1e\xfbP3~\xa7\xad\x1cTl\x9f\x0f5\x14\xfcG\
\xb6\xfa\x02\xf9C\xf59\xe2Dv+o\xc5\xa7"1\xac\xa3*\xaa\xcf\xee\xe1\xf3\xea2D$\
\x00\x04\xe0\xdb\xca\x98\xcf\xa8CP_%\xc3l\xf0\xf9\xe6<\x10\x11\x89\x80\xa8\
\xcf^HW\xd1;4C\x00\xd2\xb9khT\x888\x9b\xb4@B\x04\xc0)0y\xa7{\x18\x84t\x08\
\xac\xa3R\xcb\xa4|\x83\x81Q\xd3\x9b&\x87k\x91`N\x80\r\xd1\xe2\x90L\x1c\xfa\
\x8d\x85\xb1]"%\xf6\x15\x11!\x02\x11\x00\x01\xa2\xf3\x08h\x14\x00(\x97x\x9f\
\xfa\xde\x85\xdb\xc75dqP-&*\xc0\\H|\xef\x86\x1e\xeb[6&t\xa2\xc5b"\x1b\x03\
\xad\x10Q\xc1\xc6\xb6\xf5>s\xfb\'\x0bl@\xb5^l\x16\x03\x19\x0e4\xd7b\x0f|\x95\
tT.\x0cy\xb8\xd8W\x05\xf0\x86\xc4\x8d\x902\xd7\xcf\xfa\x1e\x17\x98\x07\xe9\
\xbd*\xb1Sn\xc1\xe7y\xd0v\xe6-\rw$\x81j\xc1-J\x84\x80\xb6\xafN\x12(\xef\xcc\
\xed\x19\x80Q\xa9\xaa\xfe\xa4\xc8\x17\xe9jq\rp\x9cT\xf7\xba\xe3\xac&\x9d[\
\xd4\xc7\x0c\x00[l\x1a\\:?\x9f\xa3|e\x81qj9\t\xa4\xc6\x03\x8b\xf3x.\x14\xe4\
\x16\xb3\x95d\xca\xe2\x15\x16\xb9\xeb\x1a\x0f\x84\xa5\x89\x16a\xc0\xd5\x80\
\x06\xd5AM<9y\'\x96\x86ja\xbb\xaa`\x0f\xf2\xe96-9\x90\x08\xca\xab\x18\x06\
\x80\x86tQ\x12\xa8d\xa0cZ4^\x82\x88N\xb9\xc1h%0\xfe\xea\x19\x92@\xc5;[\xb5\
\xacu\xee\xf2\xef\x1d\x06\n\xcc\xba\xb9\xb0!\xe9\x1e\x93LS\xe7\xcb\xcbD\xb2\
\xc7\xf7]Is\x0b\xa9\x04\x08\x03\xceK\xa9\xd5\xa7;\xed\xfd\xbe\xc5\x02\x0f\
\xc9\xb1a\x00\xd2\xb5\xe2\x9fEt\xc2=\xc6\x16\xddW\x1c\xcd\xc6\xb0\xd6\xcd%a\
\x07E\xcd\xc3\x0b\xf1*\xdb,,l+\xb1\x18\xcc\xcc%\xf5\n\x0e\xca\x91\xa2\x17b9\
\xb6[j\x17g\xfa\x16\xbc\x98\xd9\x12\x03\xf1i\x1a!\x8e\xda\xcb3^\x0c\x1c\xef\
\xee\xad\xb8R%\xa4$\x8aJB\xe2*}a\xae\x9a\x94pp)\xb2P\xeb\x9c\x82\xd4\x1a<\
\xa5\xa2K\xed\xb2\xa4\x07\x8e\xe4\xa0~%Z\x1dD\x80P\x01\xb0A\xfa\xc5\xe3y5\
\x03/\xa4<\xe2\x89\xb6\x82\x11\x92e\xdc\xcc\x1e\xaaf\x08\x05e\x8fxD\xc3\xf9a\
fK\x94\xeb]\xd2Pqla\x0f4\xad\xa2"\xddDba\xf6L\xe9\xa5\xeeXN"\xf2{_t\xc3P\tT\
\x0e7\x1d\x01Km$\xf1]\x8c\xa1\xcf \x8b\xc5\xba\x1c\x806T|k\x85\x08\x98\x0c\
\xacm\x8dZ\x18\xa9\xc5Rk[q\x15Q\xa8"\xda\xa6\xd8m[\x1b@A\xbaR&\x89\x96\x8e\
\xff\xb0\xbc@\xe3K\x14U\x87d\xac$5P\xf5U\\p\xdcN0\xba"8\xe9`%\xc9\xaa\x11|+)\
\xff\xdc\xf6Ak%\x10\x86\x8aK.\xb2C{\xa8\xb6^\xb2\xaa\xb4A\x8d{\xb2\xab\xe1\r\
\x86O\x0e}%\xbfe\x1d:\xccn\x9bS\xcb\xd0g1\xb0\xaeLL-+\x15\xdf\x8e\xf9w\x12\
\xeb&4k%\xe1\x18\x08\x9d\x07\xf9\x1er5\xfa\rm\x1cV\xb4^y1\x06.\x1b)\xdd\xdf\
\xa2\xd3\t%L\xbc\xd1\x90\x06\xdb\x86\xe6\x0c\xa3\xd2,[,\xdc;-[5\x7f\xd3\xd8\
\x99\xb9\x9e\xc9A\x82Dd\x9fd\'[\x95\xec\x89\x9b\x9d\x94\x95\xe2\xc0v~\xf1\
\xc3\x11OEB\x10\x11O^?\xeb\x9e[\xa2\x04:\xc0\xee@\x82,\xbb\x05\x1bv\xc7\xc7l\
\xd9]\x90\xe3\xda\x00hk\x9f\xfb\x9c]\xe8=d\xa7\x85\x95\xe2\x1cw\xc6\xf4f\x85\
\xc25T\xcaP\xd6J\x8c\x84\xc7\x85\x88P\xb9\xab\x8c{b\x15\xe7\x8d\xcdE;u3md\
\xfb\x81\xdaJ4Fs\'\x0c\x8eU}\xff\xbe\x9d\'\x18L\xa46\x9b[\xfb<\x94T\x9f\xbd\
\x0e\xe4\x1a\xea\t:aP\xee\x8a\x02\x0f{\xf6c\xbe\x82\xe3\x0c\xbd\x1b\' \xc5\
\xad\xb5c+\xd90\x81\xb5\xad\x1atRJ\xc93c\xad\xa9&\xd9\x80\x04\xc9\xf7\xc2\
\x95\xa4J<\xa4\xaf1\x1c.6\x90\xf3\xe8^\xb7\xf7\xf8\xd6\x12g\xb7:\xcf\x94\x96\
\xb1z\x8a\x92\xcen\xa4d\xe1xz\x9e\'z\xa0\x14\xb6\x9bRK\\\xb0\xf3)\xe7\x19\
\x12Z\x80\xd7\xb2\x9c\xfe\x9a\x98\xab&\xfb\x0eJ\xf2\x8f\xcc\xe7\xb0\xbb\xf6^\
m\xdd\xf9\x8d\xb4\xc2v\xe55\xd4\xc9\x8b\xb2\\\x85\xbf\x96\xf1\xe9\xd6\x93\
\x8a\xef\xb8\x99g\xe6\xc6\xdb\xe6z\xca\xef\xd9\x19\x80"\x07>\x97\xabvv\x08\
\xb1z\r\x1dW\xe0\xa6\xad\xa4\x8cu\x97f=\x95l\x18\x1a\x01\x03\tt_\xa8\x87d\
\x1f\x95Z\xcfT\x1f\x8eet\x95i\xe6\\4\xdc]\x0f\x9c\xed\xbd\xa3\xc8>\x1b\xcb\
\xe22BO]\x9b\xd4\x86qwc\xef~\x9b\x13\x00 k+U>\xc9\x1a\xc9\xfd\xb9\xc2l\x87\
\xabg\xbf\xf1\x8e\xb4\xf7\xb0\xa0\xbe\x8f\x04\xf1ps\xbf\xa4\x9b\x1d\xda\xaf\
\x1a\xe6\xf5\x84\xbe\x95\xe2\x9a\xa8D\xc2\x83\xa3\x18x\x9e\x9dT\xac\x93 \xeb\
C!\xf6\xe1Dd\x7fV\x0c\x8cH\xdb\x14jO\xba\x9e\xfc\nnqK\xec\xdb:\xf2~\x10;\x03\
\xb9\xb3\xaf\xe2\x0fl\xf7M\x8fm{Lc\xa0\x97\x03\xfa\x99W\xda\x8awQ\xd3X\xeb\
\xbd\xdeW\xb3\xd4\x02YT\x11#\xd8\xdce[ED2NN\x83\r=\xfa\x03\x87\xdb~\x84\r[\
\xad\x81m\xf8\x1e\xf3}+\xb3}\xf5p\xc5\x9d\x188{\xc0v\x01\xd9\xeesK\xa9\xc5*}\
_A\xb7mP\xc3\xcd\xc8n\x81M\x9d$<\xe7^G\xc0U\xe0>\x0f\xf4\x97\x17=)\x9c\x1cR2\
\xa1/\xb8\xceQ\x0c\x9cmV^\x86{\x86\xba\x19\xea\x1d*`An\xe1n\xcb\x0b}\x0b\xf7\
\xbc\x82\x14\x9aj\x02,K\x97\xca\xa2\x01\xff\xb9\xd1\x87\xb8%\xbd\xeb4!S\xd17\
\xa8{\\\xe1\x85\xf2^<\xf0\x96\xfc\xa1\xfa\x1c\xf9C\xf5Nb\xabz)\x9f\x8aj-\xaf\
\xac\xf0Od\x9dl\xbe\xd3V?\xd9\x16\xf6\x9bK}\xa3\xb7\xd1a|g)p\xfe\x01\xdd\xb7\
h\x18\x9c(\xfd\x96\x00\x00\x00\x00IEND\xaeB`\x82\xd4\x15\x04\x82' )

def get43Bitmap():
    return BitmapFromImage(get43Image())

def get43Image():
    stream = cStringIO.StringIO(get43Data())
    return ImageFromStream(stream)

index.append('43')
catalog['43'] = ImageClass()
catalog['43'].getData = get43Data
catalog['43'].getImage = get43Image
catalog['43'].getBitmap = get43Bitmap


#----------------------------------------------------------------------
def get51Data():
    return zlib.decompress(
'x\xda\x01Y\x06\xa6\xf9\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x06\x11IDATx\x9c\xed\\\xdb\x8e\x9c0\x0c\xb5W\xfb\xff\
\xbf\x9c>$\x18\xdf\x13g2\xed0\xeaQ\xc5\xc2\x90\x80\x0f\xbe\xc46\xa8\xd8Z\x03\
\x00D\x84\xaf@\xa7\xf3\x0b\x00\x88\xd8\x0f\xbe\x00\x9d\x0b\xc2\xc5\xefk\x80\
\x88?\xffZ\x86\xb7\xe0\xb7\xff\xe1~\xd5ZS\x87\x7f[\xa8\x97\xf1\x9d\xba\x1a\
\xacH!\\3\xad\xb5\'*\n\\]u\xf3{(\x9f\x0e\xcd\xea\x0b(\x81\xab\xab\xa7S\x82\
\xc4\x02\x1f\x8d_u\xdc\xc3\xba\xca6>\x8a\xe7\x8a)iV\x10\x10+\x99%"\xbeb\xc5\
\x88\xe1\xed\x16\x9f\xaf\xbf^\xad\xa7\xbc\xee\x98\xd6Z4\xb5\xff\x9el\x13J\
\xeb\xf8Q\xc2\xf5\x1du\x18A\r\xe6\xe8\xc4\xac\xdc\x00\x00\x98m\x8f\xc4\xaa\
\xfd\xdc\x82\x93\xf1\x89\x8dsb\xdb\xd8)\xb5\xc5\x19\xa5u\xf7\x1e~\xa5.7}`\
\xf6\x06N9\xd3ZW\x10\x97~;\xec\x94"\x96\x13-\xb6o\xe0\xd6ivh\x12\t\xa2J\xaf\
\x87\x9fu^\xe5\xf5\xaaz\xb6K\xc9\xb7\tT\xb9\xb0\r\xad+\n\x00\xd13\x9b^qZY\'U\
\xcf)\x08]M\x03\xc0)\x10m\xbb\xdc\x1f\x8e\x81n\x00H\x0e\x13\xe4#\xc9\x1ay\
\xf9C?\x1ey\x9az\xbd*\xc9\xf7\xb1\xf8\xeaZx\x0f\x8b\x91-B\x92\x9a\xbc\x08\
\xbf\xc2\x8f\n~>s\xf1\x94\x0bZ\x9a:\x8e\x13\xbb#\xfb\xc8h\xfb]\x03\xc9\xd4\
\x8f|\x19pO%\xe0dTH|\xbd\x1e7\xb9\x05\xa5\xa2\x95\xa4)\n\xd0\x11\xb7\xc8t;%\
\x9a\xbbM\xcc\xa9\x1a\x17g&\x89\x0f\x17.\x02\x1fp\xbc%~2\x06vo\xe1\x87\xd3\
\x04\xc5\xcd\xb0.\xaf\xd3\x17\\\xc7Nvk\xc1<\xa4W~\x99\x1e"\x0f\x94\x9e6\\a/\
\x96\xbc\xca\xea\xf2l\xc0\xabv\x8ad\xb5>\xc3\xb6\x80\x884]Qj\xf5\xfae\x9f\
\x95\x93a\x01\x00r\x99\x86\xde\xf8x\xc5PX#\xdc\xb3\x80=\x8e\r\x13\xdc\xf1+\
\xb2\xfb.\x04x!\xb3\xc1\xcdMmA3\xbc\xf5l\xb5\xd4\x006\xc2HMW\xc8j[\xdd\x8d`d\
\xb8\xa0\xb6u1\xce\xca*0R\xc8\xde\xf2\\`5L\xffR\x0e\x80\x96\xcc\x15\x82\xa6\
\\\x17\xf1\x18\x8eu_+\x8a\xa6\xbe\xcb\xaf\x86\xc9!\x00\xde\xf7\x90\xfe\xe3\
\x90\x049\x12\xc8\x08Q\xc8zVQ\xb0\xeeWM\xfc\x01`\xae\xa2\x9c\xea6B\x10\x83\
\xfb\xbf\xf0\xfa\x81\xa2\xde\xefW\x08\xd0\xb4\xa2\x9c}0\xfb\xc13\xe7\xe6\xe7\
\xdeM\x1cV\x14\xb7\xcc\xea2?!\x90T\x94k\x84\xeerl\x03\xba\x7fO\xe9\x90\xeb\
\xa8D\xf6\xf8\x1e\x14\x03\x8cXw\x8ek\xf7\xd90g\xd9%w%\xef]O\x15\x97Y\x8d5\
\xf2\x96C\x89\xe5\xbb\xd6k\xed\x9d\xcbu\xc3\xae}\x84\xb2_\x8d]\xa3+5P\n\xa7\
\xebK\xeaZ*\xa7\xba\xf3,vM\x9b\x85L\xb1\xac+\xb9p\xb8\xba\xb2\xf1\x90\xcb\
\xeaV\\*N\xf2\x1f\x1b\xfbW\xd5\xf3\xb2\xae\x10\xf8\x83\xcdu%O\xe9\xe6\x84\
\x12\x91\x9c*I5\xdc0\x93\xa0n\x81\xde\xca\xdb\x02\xcb\x04\xa3\xd5\x12\xaad\
\x08\xcb\xb9E\xbfM\xa0+\xf7\x97\xfcwk\xc3|0\xaf\xd3\xa2%!\xc1*+U\x17A\xa0\
\xae[,5\xfd\xda\t\x93#\x96\xe0\xabub\xa3p\\\x8d\x16\xbc\xd8\xbe\x18\xf2\x1bk\
QV\xa4\xe0\xcc)\xd8\xf0_@V\x9f\xeb\xbd\x8d\x9a\xae@\xa6\x08\x9c\x8c\xd2\x95\
\xc24\'\xb2E\x8a\x88\xecE\xd7*\xe4\xec}\x87\xb7\xf9\xa3T\x10\x98\x1e\x16\x9f\
\xaf;\xec\xd6^\x1b.\xbd\xc8lGW\xe1\xbd\x19h\xc5N\xa2\x05_\x82U\x9c\xd0&-\xd7\
\x95)\xea\xbaR\xbf\xa7\x15.\xc8&\x0c\xc8x\xe3.\xc1r\xee&\xb1Z\xdf\xa2\xb5\
\x86W\xee.\x13C\xe9\xe8f\x16\x04y-\x80\xd0L\xb8\xb8\x17K\xe2\xe5\xaaq\xc4(\
\xbc\xfcJ\xd4\x85\xba\xc5w\xabNgI:\xb10\xb7P7\xf5\x87\xceP\xd5\x15e@\xa5y}\
\xae\xc8qm\xbd\x9c\xe9J\x19\xc6\x0c\xeb\xeb\x95\xa8sd\x17E\xac\xcbr\x96_Y\
\xb9az\xa2\xab\xb7\xd4\xc2C\xca\xf9\x98\xa8\xb8\x80\x80\x0c\x98"\xda\xc9we%>\
E\x81\x15\xef\xf2%@5\xd2N\x90+\x0f\x7f\n.\xb7f\xc7\xcdP\xeeH+i\x12\xf3\x13\
\xb3La\xd6\x8c\x8a@\xfe"\xae\x86\xa2\x114E\x99U\xae+\xb1\xb0\xb2?\xd3\x0cC\
\xad\xbc\xac\x931.\xd2#\xea\x1b\xea+&k\xa4(\x94\x029Y\xc25]\x1d*ao\xdb\xbb\
\x9a\xaa\xa5\xd7v\xe5\xb7\x07I\xdbQ\xa7\x1d\xcc\x90\xa8%\xda\xb7H\xa9\x82\
\x89\xef\xce\xb0J\xb6\xdeQfE\x89\xc5LQr]F\xbd\xb5dT\x91\xd6Mn\xef\xcd\xea\
\x8e\xae\xc0\xa3$\xb3\x84\xc6\xb2\x10*[\xc4\x0e+4F\xa6\x0b\xf2\nG\xdf\xe1\
\xcf\x10\xc6\xbd\xd6\xa8\n\xb2\x95y\xf4r\xfe~g7\x0ek\xfe\x13\xa1\xae+\xab%\
\xf9%H\xfe\xe1\x05\xe7\xc6\xf6\xef\xebl\xb1\xd0\xd8y\xd7x\xd1\xd0|\xf8\x00w\
\x9f\xa0^\x81\x1f\xe4\xd3q\xe6\x1d>a\xcaG\rV\xf4L\xabpr\x85\xc8@\xf6Y\xa9\
\x97\xf3\xee\x9d\xa2O.h\x98\xfdh!\x124\x12\xe2\x0e\x9d\x0c/\xe9\xca\xb6\xd3\
\xd6{w\xee02i\x9b\xda\xbb\xee\xda\xab\xd8f\x9e\xd1\xe1\xef\x03\xaf.\xcd\x88\
\x04\xeb&d\x0fWN\xa9v7\xed\x9c\xff\xeaQ-SU\xd8\xbe\xfc\x06\xfe\x7f\xcb\xf91\
\x88\x0c\xe1\xa4_\xf1P\xc1M|\xc5\x96\xd6\r\xd5F\xcbd\xc0\x01Vv\xcd\xa9\xbe\
\xc2\xd8C\xb26\x9e\\\x85\xa3\xc79U\xd7\x94|br\xee\x92x\xd2\x02\x139\xb85N\
\x07\xbf~\xb6\xf4\x1d\xd3\xe4\x99%\x8f\xdc\xf6\xb1\xdd+\xb8W^\x97\x90P\xea1\
\xcd\xf2\xba\xf4,R_`\x1c\xebL\xc7\x12\xcb\xb3-wV\x9f\xb2\xde\x91\xcedF\xf6\
\xc5\xa5\xbf\x1d\xc5\xe6\xbdu\xd5ZJ\x8e\x13\x9c\x89\x81\x00\x8e\xdcbkZ\x17\
\xd4\xdcVXIMTYm\xcb\xedWY!"u\x92\xf3\xad\'\\F,\x87M\x7f9\xca\xef\xaf\xbcS\
\x8b\xd7(_9\x07\x85(\xfb\x14\x9c"\xe7Y\xb0\xa1\x02\xbf\xe0\x7fXqU\xf2xV\xae\
\x01?\x9bU\xf4V\xf6\xc1\xac"J\xf0PV*;\xfb\x1b\x15\xfe\'\xe0\xf1\x91\xdd\xe2\
\x1b"\xbb\x8b\x9f\x95\xa2\xedA\x18\xcd\xc9<\xa1z\x1c:\x9d?\x8c\x84\xcb\x85\
\x82\xf0/\xe2\x00\x00\x00\x00IEND\xaeB`\x82\xbf>#\xb0' )

def get51Bitmap():
    return BitmapFromImage(get51Image())

def get51Image():
    stream = cStringIO.StringIO(get51Data())
    return ImageFromStream(stream)

index.append('51')
catalog['51'] = ImageClass()
catalog['51'].getData = get51Data
catalog['51'].getImage = get51Image
catalog['51'].getBitmap = get51Bitmap


#----------------------------------------------------------------------
def get47Data():
    return zlib.decompress(
'x\xda\x01\x10\x07\xef\xf8\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\
\x00\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\
\x08\xdb\xe1O\xe0\x00\x00\x06\xc8IDATx\x9c\xed[\xedr\xe3 \x0c\x14\x9d\xbe\
\xff+s?\x00\xb1Z\t\x0c\xd8i\x9b\xcci:9\x070h\xd17\xe4R\xceYDRJ\xf2\x11T\xe0|\
\x8bHJ\xa9|\xf9\x00*X\x924|\x1fC)\xa5\xaf\xdf\xe6\xe1%\xf4\x8d_\xc8\xba\xdeW\
\x86]V\xdea\xbc\xaf\x0b\xf9\xa6\xef*\x9f\xf7\x85$(\xabO\xa2\xff\xa8\xde\x87>\
\x13\x15{\x8b\x90\xfe\x94\xe7X\x897K\xa8.\xe7*\xb0s\xce\xf8\xa0\x9f\xa5;g)\
\x9b\x833\xa5\xb4\x17\x15\x17\xf7wO\x03\xc3I\xb5\xd1C\xa2\x91\xc4\xff\x08\
\xd2}\xd5`T\xa9\xd1\xeeD\x85?\x04\x13r|)\x98\xf2\xfaM`\x1d\x95gbW7TJ\xa4\x8a\
0F\xf4[((;\xf8\x1c\x98\x91Un\x14\xce\x9bRj6\xc2\xa4E\x9a\xbe\xbb\xa2\x81D\
\x0f\xa6l\xb1]\xadK\t\x17\xa6\xb7\x8c6\n\xbb\n\xda\xa0\x11\x803`\x81\x0fT-Z\
\x9cB\xc7\xa1E\x8d\xb9,\x03x\xc5\xc9\xfc\x07Em\xe0-.\x97\x99\xd3\xc8a\xe4jK\
\xbaP\xd7\xdb\xcb9w\xf91\xa8&*Q\x8cJ\x9c\xe6 \xa1\x84\x8d\xb4Y3\xb7\xc3\xd4.\
\xed\xd5W\x07"\x0c\xadk\xb2\xc4\x88\xb6\xc4\xf55\x7f\xc7U\xc7\xdc\xbbl|M\x86\
G[\xb3K\xab\xb9E\xce\xb9p\x13(\x0f\x07%\xb6\xcc\x89\xf3x\x11=\x9f\xb3S\xd0\
\xc3\x8e\xfa\xef\xd5\xeb\xb2\x13ZB\xfa\xc2\xb9\xfc\xa4\x14\x91\x9b\xb8`\xe3A\
\x0e*%\xca\xb9\x8a\xa2&\xf0\x80\x19\x92F\x0f\xc9?\xfb\xafs\xea\xf1\xaa\xfa\
\xd9\xc2G\x9c@)\x97\x9dWO=UGH\xd1\xc800\xea\xd6l\xc5L"\xa7\x81j=\x01\xaf5\
\x91\x1b-\xa6N\x9f%\xdcv\x84\xc4%\xce\x1b=\x95\x07\x0e\xcf\x98\x884^\xb5\xe7\
 \x04\x15\x9e\xad\x9f\xd0\xc6\x0e,\xb7J\xab\xc8\x90\xb2\xc7c$H\xb7\xbcE2Y\
\x92\x08d\x0f\xae4\xac\x0f\xa2\x12\xcbY\x9a\x8e\r\xc5\x82I\xfe\x0em\xd4\xc2\
\xf3\xc2I\x84X\xaf\x9fd\x8d\xed\x19\xe4\xe9$\xa6\xa3\xcb\xa0\x1c\xe6\x8eS\
\xda\x93U\x98\xc8\x8aE\xd2\xc4P\xff\xc8NMV\xd5&T\xe0\x04\xa9\xce\x00\x8d/A%\
\xdd6\xa2\xce\xcc\x82\xc2F\xad&S3*}-u\xcb\xecb\xc9M\x01\xd5\xe6\xd6\xfd\xc7\
\xaa\x06:h\x96\x8f\xa6lhT\xa8\x90\x94\r\xc2\\\xb9\x15\xa3:g\xf7\xa2\xa8{\x93\
\x08\xe1iUV\xbcO&\x0eg\x18\xd6?e\x0e)g\x82\x04\xcd=$tH;\xde\xf1\x81\x8c\x89\
\xc4%\x03)e\x82\xd4\x8f\x0c\xd0\\{\xbfKY\xaer-\xa0[\xa8\xa0\x80\xf2\xe7*\xb5\
\x9d\xadH \xba\xe9`\xfb\xa2\x86>y\xb0\xc2\xbf\xa6\xca\x168\xafv\xc0\x84N8\
\x80\x84B\xc4\xf9\xda\x03\xc1\xb3\xba\xbd\x01\xef\x04\x15f\x80\xe0\xf7\xd4\n\
*C\x01$U*\x9a0Z\xe5N\x9eq\xa2\x81\xf5\x92\xdc\xb1\x93k@\x05W\x86}\xcd\x01\
\x10\x86*X\xf8\x93\xa7*\x91-\xa2<`\xc4\x00AR<\xf6\xc8\xb1\xcd\t\x7f\x94F\x95\
\x10\x97\xd7\xfd\xfa\xb9\xac\x92Q\xa6\xd9\xce\xda\x847\xaa\xdc\x8c\xb8Zc/\
\xd5t\xd8:= +\x05V\x9d/:k\xc0\x9fA\x08\xae`\xa9\x99Q\x02H~\xa7\xd6q\x9d\xcb\
\xaa[\x97\x05\x86r1\xe9"\xa4K\xc0z 111\x03\xd7]\xe5\xf0\xd4\x07\xe2\rUm\xed<\
!\xdf\x12i\x1d\x92zK\xaa\xc4`\x80N\xb8\xca\xe1Q\x1eh/\xdd.#\xc9\xce\xa1_\xfd\
\xa4"\x8d\x12\xe5KzNV\xcfQrb\x19D\xef!\xdd\xb3+\xc8A\xd5/\xdf\x7fV$X\xa4m\
\xf9\xc0=Y5\xddHp\x1e\xf5*\xa2D~\x0b\x95qD\xe3\x05L6D\xf4\n\r$u@T+\xdc\xae\
\x9f[t\x93\xb5S</\xb2]o\xe4i\x15\x159\\tS\xea\x91\x95\xa7\xab\xa9\xa2\xa2\
\xd8\x0e\xb8\x03Iv\xce\x98LI\x07\x1c\xf4\xeb6M\xde\xc3\xf30j\xcc\x9cI\x95\
\xe9D\xea\x89\xc5-`\xeb\x15~\xf0\\a\xb4g\x08/\xc6\\k:\x0b\x89E\x86M\xc2\xa3(\
\x15\x1f\x02\xdb\x85$\x1b7=\xaeE\xab]i\x89i\x08\xac\xe7~m\x1e\x85\x94\xb8x\
\xe1\x95\xfc!\xf1\xc3\xa8\xc4\xd6\xf3tu\x92\xc6\x12\x132\xa4\xa9\x93F`\xd9\
\x1e\xe3l\xd1r\xbcr\x97\xb9*\x04\x93\xfb\xd5.S \x8b\xf4\x14~T\x0e\xf7\x19\
\xec\xbe\xbc\xd6\x07\x0e8h\xb9\xc5\x80-\x99V\xf8\x98\xcb2\xe7Y$\xf5k\xae]:G\
\xc5.N\xdb]\x0b1\xae\x03($\x88mo\xaf\xbe^V\xfe\x16\xa7w\x8d\xde\xb1\xe3\x9a\
\x94\xb0\xf4*3\xfb\x17\xa3<w\x8d\xee\xc8*\xa8|\xcc\xe1\x82\xe3\x97 M\xdc\x9b\
\xaf\xb2\xb6h\xd9\x07Z\xadh\xcci\x8b\x8eRka\xad\x0b!QA\xf5\x14mx\xf6\x1e\xa0\
\x9a\xdf\xd3kU\xa5\x0e\t: \x81`)Qu\xc8\xc4E\xf1*\xf4\xe5\xdcBW\xd13\xb0\x94\
\xa4\xff\x1a\xb02\xd7!\xb5\xb7TD\xedU\x96\x92\xf4\xfd\xb2+B\xe2\xb2K;Q\xb81\
\x9a\xddeYK\x89*li#%H\xff\x0c\x06L\x91=\x81&\xef`\xda\xfe5q\xfd\xe5\x84\x08\
\x06\xd66D\xda\xd9\x19\xf2@nS"\x0c9\xc7]\x98\xbbl\xd1\xee]c.Ke\xe4\xc52\x91\
\x86gI"Um\x03A\x8d\x1cx9\xb5\xcdp\xa9\xb5BG7=\x0e\x0f\xf4\xf44\n\xcfb\x15\
\x12U1\xd8\x88\x15\xdaM\x8f\xf8\\n\x01uG\xc9\xd0\xab\x9f\x14\x11W\xa8SJ\xa9\
\xd7s\xc1\xf1\x81=*\xa5E\xfd\x91c\xa1\xf3[9\x9f\xe9\xd2W\x88\xbeZG\xf2\x95\
\x87\x16,\x87\x1a8\x88\x0cw2\xa6\xac\xe5\xea\xa8\x0b\xdf\x94\xe6H\x08RXD\xd9\
aCN\xca\xa9x\x86\xaf\xa5w+\n\xc7\xd2\x1fu\x99\x83x\xe5\xc0J\xd8\x97j\x18\xee\
\xb4\xbd\x89\xc4l\x87\xc0\xbeP\xfb\x13\x95\xc8\xd45\xa9\x81\xf9=\x1fY\xc5}\
\xfa\xd1\xff\xa9DjIR\x12\'(iv%\xf2\x03\x9e}\x87z\x16"\xabe\x85\x8fx.j\xcf\
\xe2\x8al\x9e[\xac\xeaI\x90%A\xd7A\x15\xe8W\xf6\xcc`\xcb\xabd\xe5O\x92\xb5C\
\x07\xa4\xe8\x99H\x9d>\x858\x99\x86\x96\xcd\xdf\x9c-\x88\x0b\xbcYmI\xc9\xea\
\xa1\xf5\x13g\'\x13\xb8\x96\xe7j\xdb\x07\xce\xf9\x88\x14\xe3b\xa4\xf1\xd7\
\xcb\x10\xe9\xbc\x91\xe8\xf0\xfe\xea\xb2\x1d\xd3\x85^}\x99\xdea\xf4[7\xe0\
\xd1&\x1c\xda\xd5\xdcX\xa3\xe5\x83\x19\xd0\xae8\xc9\xe2\x91C\xa3J\x8d\xb0\
\xf7%y\xa0@\x9c\x11\x97\xe2C\x9d_o\xf51\xf3Z$/%l\xb9\xf9\x9b\xb3\xd8X\x9dv\
\xcd\xd8R\x90G\x1e?\x87\xa6u\xd7\xb3\x8f \x85\x87\x10\xf4\xa2\xbdMd\xe71_eN\
\xeb\xb7r{\x1b\xe9\x87\xf7\xd3\x15\x90\x8cOL\xef8z\xa5%T\x8fg\x9f\xaf\xa6\
\xcf\xfc\x7f\xf8\xffQ\xbd\x0f}&\xaa[\xb5\xf0\xaf\xd3\xc3\x19\xd3\xaf\xd3<e{c\
YM\xe2\xcd\xbb\xcajN_7\xeb\xb6\xbfF5\x0b\xf3g\x94oM\x05\xce?T@\x83`\xa4\xb8\
\xc8\xc8\x00\x00\x00\x00IEND\xaeB`\x82\x9e\x91k\x8b' )

def get47Bitmap():
    return BitmapFromImage(get47Image())

def get47Image():
    stream = cStringIO.StringIO(get47Data())
    return ImageFromStream(stream)

index.append('47')
catalog['47'] = ImageClass()
catalog['47'].getData = get47Data
catalog['47'].getImage = get47Image
catalog['47'].getBitmap = get47Bitmap


#----------------------------------------------------------------------
def get08Data():
    return zlib.decompress(
'x\xda\x01]\x02\xa2\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\
\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\x08\
\xdb\xe1O\xe0\x00\x00\x02\x15IDATx\x9c\xed\x9c\xc1\x96\x830\x08E\xa1\xc7\xff\
\xff\xe5\xcc\xc26\xa5I4\x8e\x02\xf5Q\xeeJ\xdb\x99\xc4W\x08I@\xe5R\n\x1113\
\x85`\x95\xb3\x10\x113\xaf\'\x01X\xb50\xbd\xf4\x85\x81\x99\x1f\xdf\xbe\x06\
\x13\x16y2\x1c]\x88\x96\x8ci\xab\x81\xaaRJ\xb5\x0f\xa2\xa1\xa8\xf1\xc0\xaaau\
EPI4\xb4\x15\xba$\xeaU\xd5\x80\xc1\xcc\xb8S\xf3$Zh\t\xe3\x17*\xadMY\x9as\xe9\
x\x8a\x92\xe4\xb1\x83o\x9bG\xf6\xfe\xa7q\xb0\xd8\x87*\xe8\xb1$i=\x90B\xac\
\xdf?l\xd5{\xfc\xf51`\xd1\xe6\x94\xbdhq\x91j\xf3R\xca\xd6\xb1V_m\xd7F\xad\
\x1ftc\xa3\xae\xc71\xf0\xe2\xf4r\xfc\x1f\x8d\xc6\xf0\xe6\x8a\xc9\xb4Wk~f\'r\
\x9d\xad\xb8\xe7\x16\x0f\x07\xb3\xb0\xeci\rY\'\xfc\xb0idz\xac\xcb;\x06N/\xfd\
\xcaE8Ds\xd9\x97\xc7\xb8\xf2\x0f?\x83\x15\x93:\xfe\x1b\xd0\xb7\xadz\x8f\xf7\
\x19\x03\x16\x8c\xd7\x16\x9e\xc3@\x9d\xdf\xc8rV\x10M$\x89i\xabT\x85C\xaa\xc2\
!U\xe1\x90\xaapHU8x\xec\xaf\xc8}\x13\x10s/\xfc\x03\x95\x9e0\xa4\xaaS\xdc\xa2\
\xd2\xa3HVz\x94\xbb6\xf1\xc0;Vz\x02\x90\xaa\x0es\xafJ\x8f"w\xa9\xf4\x98\x92\
\x95\x1e\x05\xa2Wz"\x91\xaapHU8\xa4*\x1cR\x15\x0e1U9\xe5n\xd5\xd9_.\xa7\xadn\
@\x93\xab\xda\xcaX!=\xbes\xf0^?f\xf6\xb0Us5\x11\x9e\x13\xa1o\xdc\xbbf\xa8J\
\xde>.\xb31\xa7o+\x1f>\x978\xfc\xd0)w\xdb\x0f\xee\xfeR\xae4\xde|\xeb\x94\xbb\
]?q\xabe\xc5\x9c\xaf UM\xc3O\xd6D\xfeC\xfc\xdc\xad\xc5,\xbc\xd3\xa6G\xee\xd6\
"\xeeM\xdb\x04[\xddJ\x9a\xe7\xeb%\xc0\xaa*\xbdKg\r\xff,Fu{\xe9xM\xb3N\x1e\
\xa8k\x9f~=\xd9\x00\xb9\xb6\xa0\xd9\xabEPU\xd1\xee{8PUII\xfdn\r2\xb2\xcbW\
\x8b\x0c\xff\x00\xd5V\xfb@\xdaj\x1aQc\xda\xea1\x8d\xfdX<\xb3#!\xdf\xb4\xf7\
\x07\xd6\x07V\xd1#\x12\xee\x89\x00\x00\x00\x00IEND\xaeB`\x82\xae-\x1b\xf3' )

def get08Bitmap():
    return BitmapFromImage(get08Image())

def get08Image():
    stream = cStringIO.StringIO(get08Data())
    return ImageFromStream(stream)

index.append('08')
catalog['08'] = ImageClass()
catalog['08'].getData = get08Data
catalog['08'].getImage = get08Image
catalog['08'].getBitmap = get08Bitmap


#----------------------------------------------------------------------
def get04Data():
    return zlib.decompress(
'x\xda\xeb\x0c\xf0s\xe7\xe5\x92\xe2b``\xe0\xf5\xf4p\t\x02\xd2\xee@\x9c\xc0\
\xc1\x04$\x0fT\xff8\x06\xa4\x98\x8b\x9d<C888n?\xf4\x7f\xc0\xc0\xc0\xf8\xc6\
\xd3\xc51\xa4b\xce\xdb9\xb7\xfb\x0e\x19\xf0\xb8\xe4\x1e\xf9\xff\xbf\xe8\xbbb\
\x8e\xe7\xdch\xd7\xc7\x9a\xc25\xf3\x1c:\xcc.w\xce\xed\x9e\xf3j[\xae\xd2\xa2U\
\x9bX<\xcf\x05\xbb\x84\x98\xd6F6,q}\x1a\x7f\xdfh\xc5\xab\xc7\xef\xccv|0\xb9\
\xef\xdb0\xf1V\xc5\x87Ug$\x97D\x1e\xa9R\x9di\xbfd\xd2\x91\x15Jo\xf3U\xcf\xe6\
\x1c\xcc\x9e\xb2%\xe4\xed$\x8f\xbb\xab\x8fLmW\xf9\x90\xbc)n\xa7\x97P\xc8\xf1\
u\xe9\xdfj\x8b*\xf6\nn\xef\x11\x9b\xbaC\xa9w\xe9\x9c\xb8\x98\x8f\x8f\xec\xf8\
u\xe6\xb2\x7fa=\x1eh\xd1\x7f\xe9\xda\xf3\xce\xed\xd6wn\xbd|\xa5\xbe{\xe3\xe5\
\xb5\xb3\x17\x7f\x98\xcaR\xf1\xaf\xdf\xcf0&\xb0U>n\xd9\xe6g\xab.\xba\x86j\
\xbf?\xf8i\xe1\xdc\xe8\x19sgN\xd9d\xf7\xa2\xfd\x99\xd2\xe1\xf3\xc5\x95\xcf\
\x0f$^^o\xc2d\xb9\x9b\xf5\xed\xb1\x07\x97\xfdS\x8f\x99\xc8\xfe9\xf2\xe9m\xe8\
\xcd\xc7\x86\x86\x0f\x1ck\xf3\x1c\xf7\x8a\xfd\x9b\x19{\x8ee\xb1\xabev\x95\
\xe8\xaa\n\x8eP\x9b\x16-9\'Q\xfe\x85]\xed\x01G\x9dW<R\x0c\xf9(\x80OX!+\xd9\
\xe6ExKKx|\xc3J\xaf\xbc\xabj\xc6s\xb3m"_/_\xc5\xb1\xfe\xc3r.\xc1\xc2\xd6\xf5\
\xb1\xc5!S\xa7\xf7?_Z)?}\xea{\xff%\xbff\x08\x14\x86~\xb3\x12\xbe\x93\x1a\xbc\
.\xe6\xce\x9fW\x8fB_\x97\x08\xbd\xb9ri\xd6c\xd1\xa5\xab\x12\x7f\xfd\\zY\xff\
\xfa\xcfiZ\xb5\xf6\xcb\xfa\x0f]\xed\x9b \xefY\xde\xbf:\xda/{\xd2\xd9\xbcb\
\xab\xf7\xdc\x0b\xce4Z\x86>\xd7|\xbcj\xcf\xa7\xc4]-+/\x95\x9f\xaa\x9e\xfb\
\xd4@c\xdd\xb2\xf2v\xd6\xf0\x1f\x87\x93u\xa6\xac\x12\x92\xfd\xdf\x19\xfav\
\xcaj\xd3G\x1fW\x19\xcf\n\xae2\xb59}\xeaU\xa8\xfd\xca\xa0*\xd3\'\x81\xefT\
\x03>\xdf\x92\x8d\xfc\xe4[]_V r\xed\xa3\xe2\xb2h`2`\xf0t\xf5sY\xe7\x94\xd0\
\x04\x00>\xf9\x126' )

def get04Bitmap():
    return BitmapFromImage(get04Image())

def get04Image():
    stream = cStringIO.StringIO(get04Data())
    return ImageFromStream(stream)

index.append('04')
catalog['04'] = ImageClass()
catalog['04'].getData = get04Data
catalog['04'].getImage = get04Image
catalog['04'].getBitmap = get04Bitmap


#----------------------------------------------------------------------
def get36Data():
    return zlib.decompress(
'x\xda\x01\xe8\x02\x17\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\
\x00\x00\x00`\x08\x02\x00\x00\x00\xc0{\xf8\xc6\x00\x00\x00\x03sBIT\x08\x08\
\x08\xdb\xe1O\xe0\x00\x00\x02\xa0IDATx\x9c\xedZIr\xc4 \x0c\x94R\xfe\xff\x97\
\x9d\x03\x19\x87\xb0\n-\x18\x11\xfa\xe4Lp\x1b\x95@4\rx\xdf7\x00 "l\x81\x10\
\xce\x05\x00\x88\x18\xfe\xd8\x00!\x16\x84O|\xdb\x00\x11\xbf\xde\xee\x83\t\
\xae\xe7)L\xad|\x9ay\xccd!WI\xe5\xf0XH\xaa#\xf0\xbeo\x8fY\n\xd8s^\x9d\xa8\
\xfc\xe0\xea7i\xe2\xa9%*\x93P\x8bM\x94\xab\xb8<\xcaK\xa5"\x1b?\xaa\xfc\xc3\
\x92\xae\xe8\xb2\xfd\xb3y\xe5q\xf1}P\xc8U2Sk\x137\xff]2\xc5u\xd98\x9a=\xaeT\
\xb5\xe7\xb7\xd8\x02\xe1pT\xc4\x91I\xe4\xd4e{8\xcb\xd5\x02?\xe0u\x82\xd8R\
\x97-FG\xb3;\xad\x19{V\xf6\xb1\xa8j\x95\xaa[\xc1\x8aC\x9a\xcd\xd6\xc5\x9f\
\xa8\xc2\x87c\x8aP\x8bj[c\xca34\x874\x83\x8d\x82\xf2\xae\xbe\x88"{\xb7\xfe\
\x16i\xbb\x8dE\x8b\x95\xd0\x8dYV\xdd\x8av"\xba\x16\x80"\xdbo\xae\xf2\xa1,\
\x1c\xdc\xb5\x17\'\xd8!em\xa15\xbe\x1f\x12\x15)D\xff\xae\xd5zU\x9b$s\x96x\
\x13Gz\xa8\xbb\x16_\xdfS[\x1c7\xa6\xde\x89\xe4\x99\'\x85\x1c\xb81\xa3RH\xd7\
\x8d\x91\x8e\xc0\x06\xf2N\x07\x919a\xbd\x9aQ-\xe6o\xd8D\x95\xbd\xbb\xb3x\x85\
\r\x119#pq7\x06\x18\xb9r\xec\xc6\x08;Al9\xd5\x8d\xd9\x00\'*m\xffd\x92\x1bC\
\x81\xae\x7fb\xee\xc6\xf0\xb0\xa0\xba\xdd\xd6\x8d9\xf7\x98\xfc\xe0D\xe5\x07\
\xa2\xfd\xd5\x9a\x9a\x1d\x84\xb9R\xb1A-\xd8\xa4\xe7\xc2\x10]p\x95\xefD\xe4l\
\xc0\xab\x81\xba\xf6\xa5\x91\x19:\x96+]\xfb\xd2\xc8\x0c=\xeb\x95+Hw"\x92\x96\
\xbal1\xceN$\x7fy\xc9U\x98s\xe3\xa7\xd6\x89FW(\xdd\x1d:\x14\xefvlF\xb5\xd0\
\x95 \x14\x18\xfa\xec\xb18\x08\xae\xa5P4\xd0\xc1\xcf\x15\xef\xd8f\xf4p\x88\
\x07\x13\xdf\x82-\x1a\xb4|\x0b\xe9\x08\\\xf3\xca\xc5\xd1\x16d\xd8\x89\x86\
\x07\xb5{\x99\x01V\xb92\x12\rD\xccp\xce\x14%Hr\xc0U<\xe6\x12i\x8b\xd1~\xc4PT\
39\xad\xb4\x06\xae\xa9\x03\xe1\xb81\xd1;\x83\xfeI;\tCl\xcf\x94\xc9O\x90\xe3y\
5\xc3\x8di$\x81!\xac\xe2\x90\xa0r\x87\xc3\xa5\x1b\xd3M\xfe\xd1\x16\xcb\xa0[W\
\xce}\x8b\xec\x03\xc7\x8d\xd1d\xcb\xb7\x9bqq\x17U\x0b\xdd\x1b}t\xb6\xe4\xf7b\
3\x97\xd5\x02>\x0bW\xed\xbf^\xa3j\xc3\xca\x8dy\x97mOu{\xdc\x18?8Q\xf9\x81\
\xa1\xcfn\x8a\xf6\x8a\xef/WIE\xd1\xd1\xec\xebc\xdf]cb\x03x\xc7\x8f\xf5\x99\
\x18:\xde\x11\xc2\xf9\x06\xd4&\xcdn;b7\x98\x00\x00\x00\x00IEND\xaeB`\x82\xa8\
"_\t' )

def get36Bitmap():
    return BitmapFromImage(get36Image())

def get36Image():
    stream = cStringIO.StringIO(get36Data())
    return ImageFromStream(stream)

index.append('36')
catalog['36'] = ImageClass()
catalog['36'].getData = get36Data
catalog['36'].getImage = get36Image
catalog['36'].getBitmap = get36Bitmap


#----------------------------------------------------------------------
def getfcData():
    return zlib.decompress(
'x\xda\x01\xb9\tF\xf6\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\
\x00\x00 \x08\x06\x00\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\
\x08d\x88\x00\x00\tpIDATX\x85\x95\x96ypU\xf5\x15\xc7?\xf7\xbd{\xef{\t\xc9\
\x0b///\x0b"\xc4\x84M\x10\x88\x01\x01w\xd0\xba\x15\xdc\x8b\xa3\x1d\xadK\xd5j\
\x17[g\xa8\x0eZJ+T*\xa3V\xa9\xc3L\xad\xe3\xc6\xb4\xa3(:\x01\x1cV52e3\x89";!\
\x81\xb0\xe7e}\xc9[\xee\xbb\xcb\xef\xfe\xfa\xc7}\t\x81\xa2\xd53s\xe6\xfc~\
\xbf\xf7\xee9\xdf\xf3;\xe7\xfc\xceQ\xa4\x94\xfc\x10z\xb0~Z\xe0\x8b\xd7\x9f\\\
\xd2\xb0\xf1\x83QA\x15\x82*\x04T\x08\xfa@S!\xe8\xf7\xf69\xaa\xb7\x0fd\xf7\
\xba\x0f\x16/\x9c_\xbfn\xcd\xea\x15s\xe7\xce\xdd\xd6\xa7O\xf9!\x00Z\x1e\xed,\
\xdf\xb7\xb0\xaa6\xd1~tx\xbfb\xbf\xa7\\\xcf\x82\t\xfaA\xcbr\xffo\xd9\xbd_\
\x81\xe6\x96\x93\x1dk\xb6\xb5.\xad=9x\xed\xbb\xbf\x88\xee\xfbA\x00\xf6\xe5_\
\xbb\xb5\xb1n\xe3\xb4\x80\n\xa1\xf6&r2\xbd\xd8\xa3\xaa\xcf0\xdc\xe7\xad\xe6\
\x07\xcd\x07z\xa2\r\xff\xaemp\xf5-\xfdz\xeav67\xecOV\xbc\xf4\xc6\x96\x077#\
\xa5\xfc^\\.\x1aG\xae9\xe8\xca\xcf\x0e\xb9rKSZ\x9a\xd3\x8b\xa41\xb3B\x1ehw\
\xe5\xa1.W\x9e\xe8ue{\xd2\x95q\xc3\x95i\xcb\x95\xb6p\xa5\xeb\xba\xd2\xfd\xdd\
,\xe9N\xd5\xa5\x9bI{{\xd7\x95m\xedq\xe3\xce_.}\xce\xb9\xe8\xedK\xd4\xef\xeb\
\xfd\xd8\xbd+.~k\xe3\x1d\x00\x94\xd6\xd7\xb0\xb3\xb6\x03\xe8\xa0\xf5\xc6[\
\xd9{\xef\x8b\xe7\xfc\xa6\xb4\xbe\x86\xb1\xffZ\r\xc0}s\xee"\xf0\xeaJ\x1c\x17\
\x06\x85B\xc1\xa6\xc6]\xe7\xffe\xde+au\xc1\x82\x05\xca\xd7o\x1f\xff\xb4\xf3\
\xd4\x8e\xa0m\xbb>\xe1*\x8a\x10R\x01\xb0lH\x19\x90J*\xca\xca]\xdd\x93\x13yo`\
\xd9\xe0/k&\xf98\xa4\xd3P\x9aZE^\xd3\xdes\x02\xc83\x9b\xa1\x12\xcae\t\xc1\
\xba\xf5\x18\xedmX\xa1b\x84\x0b\x1d\x1d\xb1\xfcm_l\t\xaa\xf3\xe6\xcd\x93\xb7\
~\xfc\xf1_k\xdf\x7f}]\xff\x97\xf5\x9e\xc8d<#\xe94\x18\x12\x02>0\x81D\x14|A \
\x00\xe8\x90g5\x9f\x13\x80Y\x14\xc6\xb6K\xb9\xa6\xb4\x99\x9ewwc\xe6\x16c\x99\
\xa0(`eL\x7fk\xfc\x88O\x05\xa8\xf9\xea\xf6\xf5E]\xb3\x8f\xb6\x1f\xfa`X\xdf\
\xc7R\x82\xebz\xb2\x8f\x85\xf0\xce\xdc\xact\x9c\xef\x0e\xdb7\xc5\x0b\xb9\xe7\
\xe9\x10\x89\xa1:\xc9\xe2\x1186\xd8.\xf8\x14\x10\xc2%m@\x7f\x0e\x844\xfd2\
\xe0\xf8\xd9\x00\x06\xf2\xb9\xc0}\x1b\xc5\xf5\x0b\xb1Jo`\xe4=\x15tg\xc1\xda\
\x02,\x01~\xdf\xe9\xff\xf5\x03\x18~\xcb\x89vB\x15p\xfc\x10\x00> \x0f\x08\n \
\x03\xa6\x01v\x06z2\xd0e@\xaf\xfd\xdd\xde\xef\xbb\xe7\x11P\xc0\xc8z\xddg\xdc\
v\xbdw\xa1\x8f\xfa\xb1\xfcyQ\xd0)h=\x1c;[\x91\xed\x82)<\x05\x8e\x0b\xa6\xe3\
\x9d\xfd?\n\xc4[\x99~Q\x84\xa4\x05\xa9T\xc6\x936\xa4,H\x0f\x00\xdf\x7f\x03WM\
[\xe3\x9e\x9c\xd80\xe5em\xe5\x91^S\x82c\x83p1M\x81aX\x98\xa6K\xc6\xb00l0L\
\x81k\xd9^\x1c\x84\xf0\xeeW\x88~.\xbb\xa0\x0c\xe5\xb6\x87\x19;\xbc\x00u\xcfV\
\x86\xafXD\xc3\x9c\x95X\xd9[p\xe59\x00\x00\x0c\xf9|L\xe7\xb8\xdf\x17\xa7\x9b\
v\x1f\xca\x8d\x0eV\xc04\xc1\xb6\xfb\r\xb4\xb6t{\xa5\xa1\xdb\xde\xb9m\xa3\xd8\
\xb6\x97\x95Yr\xfd:\x95\xd3g\xf2\xec\xa5\xc3\xc8\xa43Lx\xe5>rc\x87\xc8\xdf\
\xb6\x92\xa3U\xb7\xe0d\x93\xf0\x9c\x00z\x0f\x0eJmYyw\xf4\xdf\x8f\xaf\xdbk\
\xb9\xf6\xf0h\x91\xce\xd4\xcb\xa3L\xbf\xb9\x92\xfc\x92\x02^|\xfasb\xc7\x93(\
\x8aWJ\x00J6\x88}g\xae_\xe53\xfd6\x9a\xdb2<\xfa\xea\xa5\xe4\xc6\xbc\x9c\x9a\
\xfa\xda]\xb4,>\x8a1\xa8\x18\xdd\x7f\xfa\n|\x9cE\x97\xdd\xb2*\xed\xf7\x89\\\
\x80a\xe5y\xa89\x01\x1a\xbe\xec\x04]\xe3\xbc\x11a\x02A\xbe\x93s4\x07\xd76i8\
\xd4\xc3\xe6G\x96\xf5\xeb=4i6\x89\xdc(\xb6p\x11\x8e\xfb\xed\x00f\xfc\xf6M}\
\xde\xfc\x0b\x83\x00\r\xf5]\xec\xfc\xaa\x93\xe9\xb7\x8d\x04McH\xe59\x00\x04\
\xce\x92A\xc8\xe9=\xca\xf1N\x83\x93\xe7U\xd3q~\x15-\x13f\xb1\xe1\xfew\xb0\
\x1d\x17\xc7qq\xc4i\x00g\x84`\xd3\xb5\x9b}\xc7\x9e\xaa\xd9\x1dj\xd2\xf3\xe7/\
\x9cH~I\x01\xf9%!\xaf\xb1k:\x13\xae\x1b\xc7\xf6Ov\x9e\x19\x82\x01\xf1\xec[\
\x0fi\xdb\xcc\xee\xfcJl!Y\xf5\x9b5\xa8\xa9\x1e\x1c\xc7E\x08\x17\xd7\x95\xd8\
\x03\xac\x9e\x01`U\xdd\x91\xf7\x0e\xb6\x1c\x1fIPcHE.\x04\x83\xa0\xeb\xa0\xe9\
\x10\xd0\t\x17\x14\x10\x8a\x04\xc9$2\xfd\x8f\x89\xaa\x02\n(}k\xa0\xdc\xfc\
\x86\x1d\xaed\xef\x918\x95e\x11\x84\x16\xc6\xb5\x05\xc2\xf5\x008\xcei\xd4g\
\x84`\xdd\xca\x0f\xc7$\x92\x0e\x89\x0c\xa0k\x10\x08\xd0~\xb2\x0b\xd7\xe7\xeb\
\x07Q=s<\xe1\xc1\x10)\x84\xa2\x08\x14\x86!\x1a\x81\xe2(D\x8b\xa0\xac\x04\xae\
\x92\x1b@Xl?\xd0\x8em\x0b\x8f\x1d\x81\xe3\xb8\xd8\x8e@\x88o\xc9\x81\x9d\xd3?\
\x9a\xf0\xf6\xd1\xe9\xe7\xcf\xf9\xf5\x97,~v\x1b\x9d\x1dib\x87O\xd0\xda\xd8\
\x0c\x9a\x06\x9a\xce\x857M\xa1$k\xac8\n%\xc5\xa7\x8dG\x8b \x1c\x86\xc2B\xb8\
\xd8\xaa\xe5T<C\xbc\xab\x87\xfc\xb6&l\xc7\x03a\xdb\x02k@\x13\xf9\x9f$\xac\
\xbci~\xec\xe9ES\xe9\x8c%Y\xb6h\x03Mu\x07)(\x1f\x06\xc1\x00\xc9X\x8c\xde\xc6\
\xfd\x84\xc3\x10\x89\xa8\x84\xc3*\x05\x05\x1aE\x91AD\n\x07QZRHYi\x11C\xca\
\xa2\xcc\t/G\xb8\x92I\x1b\x17\xf3\xb3\xa5\xd7 \r\x03\xcbr\xb0\x9d3\xab@\x05\
\xb82\xda\x19\xd9Q\xf5\xfa\x88\xc4\x86\xb9\xdbg\xdeXh[\xc9\x10\x7f|\xf3fLWaP\
\xc9`\x84\x16\xa0\xee\xc3\xed\x94%\x1b\xd14\x95\xf2\xe1C\xc9\xc9\t\x02\n\x8a\
\xa2\xa0\xeb\x1aRJ\xfc~?\xb6\xed\x00\x92\x9cd+z\xaa\x8b\xcb7/a\x90\xee\xf0\
\x93\xe5\xf7\xf3\xce\x9d\xcbp\xa5\xc4\x11\xa7\x9b\x81\xfa\xdc\x82\x03\xfe?\
\xdcpE\xeb5\xd7O\xdb\x03T\xa9#\xae\xadl\xfby\xb3\xd1r"\x96\x93\xb2\x03\xb4w\
\xfa8\xbc\xaf\x9b\x82P\x90\xf1wWb\xdb6RJ\x12\x89$B\x08\xd2i\x03\xd3r\xc8d,\
\x1cGbd<\xefz\xd2*\x0fn~\x98\xe4\x10\x9dB\xd7al\xe3:\n:\x9ai\x0b\r?\xa3\x8d\
\xab\xc7\xee\xbeH\x9d\xf8\xa4\xc3\xf6\xda\xf5\x13#-U\xf2\xe4\x03\xdd\xf4&\
\x0c\xcct\x86\xde\xee\x0c\xdd\xd9\xf6\x14\x8beX\xb3v\x0f\x9a\x0e-j%[\x9c\x19\
HG\xe0\xda\x02\xdb\x14\x08\xcb[\xf7)?\x997\x86\xce\x89\x95D6=\xc1=\xa3a\xf5\
\x1dKh\xcd\x1b\x86\xb0E\xb6\n\x14\t\xa0\xfes\xa4m~l+\x89T\xaf\x15\xf6\x1d\
\xfe\x86^\xbf\x82\xebJ,\x0b\xd2\x06d\xcc\xd3=\xa7\xae\x1e\x0e\x07/d\xc5\x15/\
s\x7f\xf92\xcc\xb4B:\x01\x8e\x01\xd2\x01\xc4\xe9\xba\x1e\xc6~t\xc5\xe2\xd3\
\xea\x87\xb0\xba\xbf\xe4\xe0\xc8\xdb\xb3\xa5(\xe9jo\x15\xaa\x1e\xb4\x06\x87\
\xcfwT\x80x\\\xb1m)\x11\x024\xdd\x93\xa9\x14\xc4\xe3^\xef\x11\x8e\xc7\x9d\
\xc1!\xd4\xcc\xf8\x1b\x1fT?\xc8\x10\xeb\x14J\x13Xq\xe8JB\xc2\xf4\xda\xac\xe8\
{\xe65`\x02l(}\x807\xe4\x02.s\\\\\xd7E\x08I\xcd\x9b/\xb4\xe4\x84\x8a:J\xc6\
\xdf\x98P\x01\xc6\x94\x8f\xff\xa8\xbeq\xe7c\xc9\x94\xf7\xee\x08\xc7\xf3>mx\
\x8d\xd0\xb2`W\xc9\x8fXS\xfd\x0c\x1fM\xbe\x97\xa1\x89S\x8c\xfd\x00\x8c\x0c\
\xb4&AI\x81\x93\x84\xa4qVIM\x80#\xbe\xd1\x94V\x8c\xc2\xce>D-_mL\x9a\x19\xe7`\
\xe9\xb8\xc9\xfb\x7f<\xff\xf16\x15\xa0\xf7\xc6\xff\xbc~X\x9b\xd7\xe9oY\xff,V\
v\x00\xd4$\x02\xc9\xbe\xc8\x15l\x1by\x1fW\x946\xb0\xe9\x82;(\xe8\x8cS\xb9\
\x1c\x14\xe1\r\'\xa6\x03\x99,\x0f\x9c\xd0V\x97\r\xb5\xf4f\xcd\xde5\xfa\xfaA\
\xb3\xf3\xfd\xa4\x12\xddb\xd7\xda7O\xc5\xdbc\xfb"\xc3\xaa\xeb\xae\x9c\xbdd\
\xf7\x8aq\xcb\xda\x15)%\xc7\x1e?V\xd2\xf9\xab\x8a\xea\x9f6\xec]\x81\x95\xc8\
\t\x89\x0en\x18\xbc\x01\x84\xe0\xba\xc2\xcf\x99\x98\xb3\x83t/h\x9fB\xc1V\xf0\
\t\xb0\x1chOC,\t\xb1\x14\xb4\xa5\xc0\x1c0)\xbd?\xb1\xb2\xa3\x8b\xa1\x07L\xa9\
\xb5\xa5\xdc\x80c\xa3I-/\xd2\x1d)\x9f\xd28y\xf6\xf3\xdf\xbc\xf5\x98\xdc\x9f\
\x9b\x99\xd4\xa1\x02\xe4.\xcc\xed\xc9\xb9\xf2\x1f\xfb\x9b\x97O\xb42\x19#\xa7\
_K\x02D\x0f8\xeb \xba\xc5\xf3\xba\x8fL\xe1ym8\xde\xdcg\r\x1c\xd3\x02\xd0!#\
\xcd\xa1\xfc\xc8\xb6\xaa\x11\x15{\xba\xf2G\xc7\xdb\xd2\x15vt\xe4\xb4\xd4\x94\
?\xado\xcf_\xf3|[\xec\xc0\xd5\xbd{\x0e\xbca+RJ6m\xda\xe4\xbbd\xf2\xa4\xd03k\
\xd5\xb1\xeb\x97>5\xa3\xab\xf5\xd8h\xcb2\xf3@\x0e\xe8u\xdf\x97\x14\xa9\xfa\
\xfc\x99\xbc\xbc\xfc\xa3\x97O\xba\xb8\xae\xe6\xbd\x05{\xa7\x7f2\xbc;z\xeb;\
\xf6k\xc7G\x89\xbf\x87\x97[\xd7o\xaf\xb6jjj\xc4\xfc\xf9\xf3\xa5\nP[[+g\xcd\
\x9ae\x8c}%}\xf8\xaa[O\x89\x1d\xf5[\xbf\x8e\'S\x9a\x94\xd6\x0f\x06\xa0(\xba\
\xd4\x82\x9aSV9\xae\xe7\xe5\'^8\xb1\xf4\xa5\x13\x1d\xcd\xcd\xcdF\xcf\xc7=\
\xee\x97u\r\x18\xcf\x1c\x93UU\x0f\xf5\xa7\xcb\x7f\x01\xdc:\x1e\xb8\xa1z\xfb\
\t\x00\x00\x00\x00IEND\xaeB`\x82\x0c\xc0\xdf\x97' )

def getfcBitmap():
    return BitmapFromImage(getfcImage())

def getfcImage():
    stream = cStringIO.StringIO(getfcData())
    return ImageFromStream(stream)

def getfcIcon():
    icon = EmptyIcon()
    icon.CopyFromBitmap(getfcBitmap())
    return icon

index.append('fc')
catalog['fc'] = ImageClass()
catalog['fc'].getData = getfcData
catalog['fc'].getImage = getfcImage
catalog['fc'].getBitmap = getfcBitmap
catalog['fc'].getIcon = getfcIcon


#----------------------------------------------------------------------
def getdaData():
    return zlib.decompress(
"x\xda\xeb\x0c\xf0s\xe7\xe5\x92\xe2b``\xe0\xf5\xf4p\t\x02\xd2\n \xcc\xc1\x06\
$\x8b\xab\xaa\xbe\x00)\x96b'\xcf\x10\x0e \xa8\xe1H\xe9\x00\xf2\x17y\xba8\x86\
D\xb4\xbe\x9d\xee-\xd4\xa0\xc0\xe3\x1c\xfd\xe1\x9fyX\xcc\xd5@7\x03]\x83\xd2\
\x8b9?\xf7\xba\xb4k\x14\x9fjY!S\xfd\xb2\xb7\xf8\x14On\x88f\xa4\xd8\xd9+\xcbb\
\x03N\x19s\xa4M\xfe\xe8\xfd\x8e\x93\xc5\x81\x01\x88v0\x97\xac\x7f\xb4\x9e)\
\xeb\xecU\x91\xcb\xfb\x85\x05\xae\xb2^\x91\xda,2\xb9\x9a)\x96\xa1rZ\x87\xf1\
\xcc\xc5\x7f\r~\x963\xb9Dp\x85}\x178\x90\xe5\xc8\xb0W\xc4\xed\xcea\x06mV\xe6\
=K\r^\xc5\xb1n\xf0\xea\xf97\xa3\xe3U\x9dD\xa1\x7f\x8a\xc7\x83\xba\x07/\x1e\
\xba\xb4\xb1\xa4\x9d\xfe+\xcb\xc1P\xde \xdc'/\xb9*J\xc4\x82\x03\xe8Z\x06OW?\
\x97uN\tM\x00\x0fOT\x17" )

def getdaBitmap():
    return BitmapFromImage(getdaImage())

def getdaImage():
    stream = cStringIO.StringIO(getdaData())
    return ImageFromStream(stream)

def getdaIcon():
    icon = EmptyIcon()
    icon.CopyFromBitmap(getdaBitmap())
    return icon

index.append('da')
catalog['da'] = ImageClass()
catalog['da'].getData = getdaData
catalog['da'].getImage = getdaImage
catalog['da'].getBitmap = getdaBitmap
catalog['da'].getIcon = getdaIcon


